java15：面向对象
类 对象
class object（按照 英文就是东西，但是专家说是对象 so 我们就学对象）
类 class 就是 类型
因为 对象 object ==》 东西 啥都是东西 ==> 啥都是对象 《== 专家的说法 一切皆对象
是结构化数据
类是对象的分类
类是对象的数据结构定义==》 对象有什么数据由类定义
创建对象，需要有类型， 用类型创建对象 类是对象的结构模板
使用new 类名() 来创建对象 也叫做实例化
对象创建后，成员变量可以按照默认的方式初始化
数值类型 0
int 0
byte 0
short 0
long 0L
float 0.0f
double 0
boolean类型 false
char类型 \u0000
引用类型 null
为了能够对实例化的对象进行访问控制，需要一个特殊的变量， 就是引用
引用类型
8种基本类型之外的 用类名（接口\数组）声明的变量 就是引用类型变量
引用类型变量的值中存储的是某个对象在内存中的地址信息，在一个引用类型变来那个指向该类的对象，就可以通过这个变量对 对象 访问
方法：
在类中定义
代表对象的行为 就是功能
方法实现是利用算法操作对象的数据实现
使用对象调用方法
this 关键字
this 在方法执行期间代表调用方法的“这个”对象。是动态绑定到当前对象，方法在方法区中通过this 识别不通对象的调用。
代表当前对象本身是方法的隐含参数，接受对象引用
本质
堆栈 里面是数据
方法区是算法
package day15;
public class Demo01 {
public static void main(String[] args) {
dog wangcai = new dog();
wangcai.age=3;
wangcai.name="wangcai";
wangcai.sex='m';
wangcai.color=0x505050;
System.out.println(wangcai.age);
System.out.println(wangcai.name);
System.out.println(wangcai.sex);
System.out.println(wangcai.color);
wangcai.eat();
}
}
class dog{
String name; //实例变量 ： 每个对象实例拥有一个name
int age;
char sex;
int color;
public void eat(){
System.out.println("吃");
}
}
package day15;
public class Demo01 {
public static void main(String[] args) {
cell c1 = new cell();
c1.row = 1;
c1.col = 5;
c1.color = 0x505050;
cell c2 = new cell();
c2.row = 1;
c2.col = 6;
c2.color = 0x505050;
System.out.println(c1.row);
c1.drop();
c2.drop();
System.out.println(c1.row);
System.out.println(c2.row);
}
}
class cell {
int row;
int col;
int color;
public void drop() {//下移
row++;
}
public void leftShift() {//左移
col--;
}
public void rightShift() {//右移
col++;
}
}
在同一个包中不能声明同名的类
构造器（使得创建对象方便简洁）
构造方法：创建和初始化对象的方法（初始化属性）
构造方法在类中声明
构造方法的方法名与类名一致
构造方法不能声明返回值
使用new运算调用构造器，创建对象
java根据构造器参数识别 不通的构造器
package day15;
public class Demo01 {
public static void main(String[] args) {
dog xiaowangcai = new dog("xiaowangcai", 5, 'm', 0x404040);// 对比wangcai的声明xiaowangcai的声明更便捷
//dog xiaowangcai2 = new dog("xiaowangcai2", 4, 'w', 0x606060);// 创建对象很便捷啦。
xiaowangcai.eat();
//xiaowangcai2.eat();
}
}
class dog {
String name; // 实例变量 ： 每个对象实例拥有一个name
int age;
char sex;
int color;
public dog(String name, int age, char sex, int color) {// 构造器（构造方法）：为更便捷
System.out.println(this.name);
this.name = name;// 方法中的参数是局部变量
System.out.println(this.age);
this.age = age;// this.age是实例变量
System.out.println(this.sex);
this.sex = sex;// 为了区别 就使用this. 区别方法参数和实例变量
System.out.println(this.color);
this.color = color;
}
public void eat() {// 方法
System.out.println("吃");
}
}
java 构造方法和方法
构造方法（构造器、构造函数） 对比 方法
构造方法：方法名一定与类名一样，不能定义返回值 试用new运算调用构造fangfa
方法：方法名一般不与类型一样，一定定义返回值 没有返回值的使用void的定义 试用引用调用方法
构造方法：用于创建对象初始化属性：创建个小旺财
方法：是对象的行为功能：狗吃东西
类型用名词
方法用动词
名词 + 动词
重载：
名字一样功能不同
运算符：+ 数值相加 连接字符串
方法重载：方法名一样，参数不同
构造器重载：构造方法名一样，参数不同
package day15;
public class Demo01 {
public static void main(String[] args) {
dog xiaowangcai = new dog("xiaowangcai", 5);// 对比wangcai的声明xiaowangcai的声明更便捷
dog xiaowangcai2 = new dog("xiaowangcai2", 4, 'w', 0x606060);// 创建对象很便捷啦。
xiaowangcai.eat();// 调用重载的方法
xiaowangcai2.eat("骨头");// 调用重载的方法
}
}
class dog {
String name; // 实例变量 ： 每个对象实例拥有一个name
int age; // 属性
char sex;
int color;
public dog(String name, int age) {// 构造器（构造方法）：为更便捷
this.name = name;// 方法中的参数是局部变量
this.age = age;// this.age是实例变量
System.out.println(this.name);
System.out.println(this.age);
}
// 构造器重载 参数不同 没有 sex 和color
public dog(String name, int age, char sex, int color) {// 构造器（构造方法）：为更便捷
this.name = name;// 方法中的参数是局部变量
this.age = age;// this.age是实例变量
this.sex = sex;// 为了区别 就使用this. 区别方法参数和实例变量
this.color = color;
System.out.println(this.name);
System.out.println(this.age);
System.out.println(this.sex);
System.out.println(this.color);
}
public void eat() {// 方法
System.out.println("吃");
}
// 重载的方法，方法名一样，参数不同
// 调用有参数的就执行下面的
public void eat(String str) {// 方法
System.out.println("吃" + str);
}
}
null
空指针异常：引用变量的值是null，没用引用任何对象
在null引用上调用了方法 属性会出现空指针异常
在访问方法 属性之前 对引用变量赋值，使变量引用对象 ==》解决
有变量没有对象
访问属性
调用方法
package test;
public class One {
public static void main(String[] args) {
// 类名 引用 对象
dog wangcai = new dog();// 使用new 来创建一个对象 旺财 调用默认的构造器
// new dog 是为 dog 类 为模板 ，在堆中创建一个dog类的对象
// 末尾的() :在对象创建后，立即调用dog类的构造函数，对刚刚生成的对象进行初始化，
// dog wangcai 创建一个 dog 类的引用变量， 对象引用 栈中
// = 是对象引用指向刚刚创建的dog对象
dog wangcai2 = wangcai;// 赋值 引用类型之间的赋值不会创建一个新的变量
dog xiaowangcai = null;// dog xiaowangcai 创建一个 dog 类的引用变量， 但是他指向空 就是没有对象
// xiaowangcai.name = xiaowangcai;// NullPointerException（空指针异常）
// 当一个引用的值为null的时候，如果通过引用访问对象成员变量或者调用方法是不合逻辑的
// （因其没有指向某对象，自然不会有属性和方法）
wangcai.name = "wangcai";// 通过 引用类型变量 访问 实例变量
wangcai.age = 5;// 访问实例变量
wangcai.print();// 调用对象的方法
wangcai.print("是一个狗");// 根据 参数类型 调用了重载的方法
wangcai.print('m');// 参数类型 调用了重载的方法
cat tom = new cat("tom", 4); // 调用构造器使得创建对象方便简洁
cat kitty = new cat("kitty", 3, 'w');// 调用重载的构造器
kitty.print();
}
}
class dog {// 创建一个类
String name;// 类中创建的实例变量
int age;// 类中创建的实例变量
// public dog(String name,int age){//构造器
// this.name = name;
// this.age = age;
// }
//
// 方法的签名包含如下两个方面：方法名和参数列表
// Java语法规定，一个类中不可以有两个方法签名完全相同的方法，
// 即：一个类中不可以有两个方法的方法名和参数列表都完全相同，
// 但是，如果一个类的两个方法只是方法名相同而参数列表不同，是可以的
public void print() {// 类中创建的方法 print
System.out.println(name + ":" + age);
}
public void print(String thing) {// 重载为了好看 优雅
System.out.println(name + thing);
}
// public void print(String sex){//重载 根据参数的类型判断
// System.out.println(name+sex);
// }
public void print(char thing) {// 重载
System.out.println(name + " is " + thing);
}
}
class cat {
String name;
int age;
char sex;
public cat(String name, int age) {// 构造器
// JAVA语法规定，任何一个类都必须含有构造方法，假如源程序中没有定义，则编译器在编译时将为其添加一个无参的空构造方法（此方法称之为“默认的构造方法”）
// 使得创建对象方便简洁
// 构造方法的名称必须与类名相同。
// 构造方法没有返回值，但也不能写void。
// Java语言中的构造方法常常用于实现对对象成员变量的初始化
this.name = name;// this关键字用在方法体中，用于指代调用该方法的当前对象，
// 简单的说：哪个对象调用方法，this指的就是哪个对象。
// 严格来讲，在方法中需要通过this关键字指明当前对象
this.age = age;// 在构造方法中，用来初始化成员变量的参数一般和成员变量取相同的名字，这样会有利于代码的可读性，但此处就必须通过this关键字来区分成员变量和参数了，而不能省略this了
}
public cat(String name, int age, char sex) {// 重载的构造器
// 很多时候，为了使用的方便，可以对一个类定义多个构造方法，
// 这些构造方法都有相同的名称（类名），只是方法的参数不同，称之为构造方法的重载。
this.name = name;
this.age = age;
this.sex = sex;
}
public cat(String name) {// 重载的构造器
// 使用了this关键字，在构造方法中可以通过this关键字来调用另外的一个重载的构造方法。
// this ( name,3,'w')调用了cat(String name,int age ,char sex)构造方法
this(name, 9, 'w');
}
public void print() {
System.out.println(sex);
}
}
最后：对象就是东西！！！