1 类和对象（重点） 引入：在程序的世界中一切皆为对象
面向对象和面向过程思想： 面向过程：关注做了什么事，而不关心是谁做的 面向对象：关注谁做了这件事
1.类和对象（重点）
引入：在程序的世界中一切皆为对象
面向对象和面向过程思想：
面向过程：关注做了什么事，而不关心是谁做的
面向对象：关注谁做了这件事
生活案例：
面向过程：白白的皮肤，修长的腿；特能吃
String color = "白色";
double height = 1.5;
eat(); //吃的方法
面向对象：佩奇的特征--肤白，腿长， 行为-能吃
Dog peiQi = new Dog();
peiQi.color = "白色"; //特征
peiQi.height = 1.5;
peiQi.eat(); //行为
面向对象描述：世间万物皆为对象，每个对象都有特征和行为
特征：以名词形式出现--属性
行为：以动词形式出现--方法
什么是对象：具体化的一个实体
什么是类：所有实体共同组成的集合
类的抽取：相似的对象共同特征和行为可以进行抽取，放入类中；表示一类事物的特征与行为
例如： 泰迪，藏獒等对象都有姓名，年龄及吃的行为，可以将他们放到狗类中
2. 面向对象编程(重点)
注意：在现实中有什么具体案例，那么我们就可以通过代码来实现
面向对象的编程设计：（重点）
创建一个类，类中有属性和方法，实例化对象，通过对象调属性和方法
=====================面向对象编程设计=====================
//案例：家里养了一条叫旺财的狗，特能吃
//分析： 类-狗类 对象-new对象 属性：姓名 方法：吃
//1.创建一个狗类
public class Dog {
//2.类中有属性
String name; //旺财
//3.类中有方法
public void eat() {
System.out.println(name+"特能吃...");
}
}
public class Test {
public static void main(String[] args) {
//1.实例化狗的对象
Dog dog = new Dog();
dog.name = "旺财"; //赋值 对象调属性 ： 对象.属性
System.out.println(dog.name); //取值
dog.eat(); //旺财能吃？
}
}
=====================创建多个实例=====================
public class Test {
public static void main(String[] args) {
//1.实例化狗的对象
Dog dog = new Dog();
dog.name = "旺财"; //赋值 对象调属性 ： 对象.属性
System.out.println(dog.name); //取值
//2.实例化另一个狗对象
Dog dog2 = new Dog();
dog2.name = "小藏";
dog.eat(); //旺财能吃？
dog2.eat(); //小藏能吃？
}
}
3. 局部变量与成员变量（重点）
//局部变量与成员变量的区别：
//1.出现位置：
//局部变量：定义在方法体中，方法参数中，代码块中
//成员变量：在类中，且在成员方法外部
//2.初始值：
//局部变量：没有初始值，不赋值则报错
//成员变量：有初始值； String-null，int-0
//3.作用域：
//局部变量： 在方法体中，出了方法，则销毁
//成员变量：至少在当前类中（成员变量有权限问题）
//4.重名问题
//出现重名，重叠作用域，局部变量优先（作用域小的覆盖作用域大的）=======================女朋友洗衣服案例=======================
class GirlFriend{
//属性的初始值问题： String-null int-0 与数组类似
String name; //成员属性(成员变量)
int age;
public void wash() { //成员方法
String name="凤姐";
System.out.println(age+"岁的女朋友"+name+"正在洗衣服");
}
}
//案例：女朋友小丽正在帮我洗衣服
//分析： 类：女朋友类 对象： new 属性： 姓名,年龄 方法：洗衣服
public class Test {
public static void main(String[] args) {
GirlFriend gf = new GirlFriend(); //实例化对象
gf.name = "小丽"; //给属性赋值
gf.age = 18;
gf.wash(); //调方法
}
}=======================打印学生信息案例=======================
//案例：创建一个学生类：
//属性有：姓名，年龄，性别，分数 方法： 打招呼（打印所有属性信息）
//实例化多个对象，并赋值及打印
public class Student {
String name; //null
int age; //0
char sex; //空格
double score; //0.0
public void sayHi() {
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("性别:"+sex);
System.out.println("分数:"+score);
}
}
public class Test {
public static void main(String[] args) {
//实例化第一个对象
Student st = new Student();
st.sayHi();
System.out.println("--------------");
//实例化第二个对象
Student st2 = new Student();
st2.name = "李凯";
st2.age = 18;
st2.sex = '男';
st2.score = 88;
st2.sayHi();
}
}
4. 方法重载(重点)
//概述：在同一个类中，方法名相同，参数个数或类型不同
//好处：方便统一管理相关功能
//案例：小明在吃饭，在吃药
//类： Person类 对象： new 属性：姓名 方法： 吃
class Person{
String name;
//------------方法重载--------------
public void eat(String rice) {
System.out.println(name+"在吃"+rice);
}
public void eat(String rice,String yao) {
System.out.println(name+"在吃"+rice+";吃完后，有在吃"+yao);
}
public void eat(int number) {
System.out.println(name+"在吃"+number);
}
//下面的是否为重载方法?
/*
//注意： 返回值不同，及参数名不同不是重载
public int eat(String fish) {
return 0;
}*/
//关于jvm调用：1.方法调用时，先通过方法名确定，调哪个方法；2.如果方法名相同，则看参数列表
}5. 构造方法（重点）
//案例：手机有打电话功能
//类：手机类 对象：new 属性：品牌，价格 方法： 打电话
//实例化对象的过程：
//1.在内存中开辟了一块空间
//2.给成员属性赋予初始值
//3.调用构造方法实现
//4.将地址赋值给引用变量
//构造方法：特殊的方法，在实例化对象时进行调用
//组成部分：1.构造方法调用 2.构造方法实现
//1.构造方法调用: new 类名();
//2.构造方法实现: public 类名(){};
//注意：
//1.当我们没有写构造方法实现，系统会默认生成无参数构造方法--查看反编译工具
//2.当我们写了构造方法实现，系统则不会默认生成构造方法
class Phone{
//成员属性：
String brand;
int price;
//----------构造方法也具备重载的特点----------
public Phone() { //无参构造的实现
System.out.println("调用无参构造");
}
//带参构造：往往带参构造用于给成员属性赋值
public Phone(String b, int p) {
brand = b;
price = p;
}
}
public class Test {
public static void main(String[] args) {
//1.无参构造
Phone phone = new Phone();
phone.brand = "华为";
phone.price = 1999;
System.out.println(phone.brand+"=="+phone.price);
System.out.println("--------------");
//2.带参构造： new 类名(参数)
//带参构造 = 无参构造+赋值
Phone phone2 = new Phone("三星",3999);
System.out.println(phone2.brand+"-->"+phone2.price);
}
}
6. this用法（重点）
//案例：创建汽车类 属性有： 品牌，价格 方法： 启动
//this：当前对象，就是谁调用this所在的方法，this就代表那个对象
//this用法：
//this调属性： this.属性-当前对象的属性
//this调方法：this.方法()
//this调构造方法： 调无参-this() 调带参-this(参数)
class Car{
//属性
String brand;
int price;
public Car() {
System.out.println("调无参构造..");
}
public Car(String brand) {
this.brand = brand;
}
//带参构造的规范写法：往往参数要与属性名一致
public Car(String brand, int price) {
//this(); //this调构造方法，只能在构造器中，且放在首句
this(brand); //不能重复使用this调构造方法，因为都要放首句，重复调则会冲突
//brand = brand; //注意：此处局部变量优先，所以赋值给了自身，跟成员变量无关
this.price = price;
//this.start(); //当前对象调start
}
public void start() {
System.out.println("汽车启动...");
}
}
public class Test {
public static void main(String[] args) {
Car car = new Car("奥迪",30);
//car.start(); //等价于在带参构造中通过this.start();
System.out.println(car.brand+" "+car.price); //奥迪 30
}
}
