!! 有get/set方法的情况基本就是说要搞个私有属性，不直接对外开放；
构造器
Person p = new Person();
//其中的Person();就是构造器；---造对象；
Constructor–建设者，建造者；
作用
- 搭配new 创建类的（对象）实例；
- 创建对象的同时，给对象的相关属性赋值；
使用说明
- 格式：
修饰符 类名（形参）{}
-****构造器的方法名和类名一样；*******
- 如果不写出构造器，会隐式创建和类同样修饰符的空参构造器；见代码Constructor1;
- 一旦显示定义构造器，隐式的空参构造器将失效（废话）；
- 构造器可以有多个- -、重载；
构造方法和 方法 没有关系；
public class Constructor1 {public static void main(String[] args) {Constructor1 c1 = new Constructor1();Person p1 = new Person();Person p2 = new Person(1);//ctrl+p;可以展示参数；Person p3 = new Person(true);System.out.println(p3);}/* 构造器1 */public Constructor1() {System.out.println(111111);}
}class Person{/* 空参构造器 */public Person() {System.out.println("person构造器被调用！");}/* 构造器可以重载 */public Person(int a) {System.out.println("构造器可以重载!" + a);}public Person(String name) {System.out.println(name);
// return name; //搞不成；搞不了返回值；}/* 这也搞不成*/public Person(boolean c) {System.out.println(c);
// return new Person();}
}
匿名对象；
new Person(); //类似这样没有赋值给某个变量；
- 只能被调用一次；
- 常常作为实参传给方法
public class Noname {public static void main(String[] args) {/*实现接口的匿名类*/Q q= new Q(){public void m1() {System.out.println("interface_Q_m1");}};q.m1();new Q(){public void m1() {System.out.println("interface_Q_m1");}}.m1();/* 类的匿名子类 */new W() {public void m2(){System.out.println("class_W_m2");}}.m2();/* 匿名子类 */new W(){}.m2();/*相当于没有重写方法*/W w = new W(){};System.out.println(w.getClass());System.out.println(w.getClass().getSuperclass());}
}interface Q {void m1();
}class W {public void m2(){System.out.println("m2");}
}
对象的参数赋值顺序；
一种对象规范？
定义：
是一种java语言写成的可重用组件；
标准：
必须有一个空参构造器；
类是公共的
有属性，且有set/get方法；
public class Bean {public static void main(String[] args) {}
}
class Customer {int id;public void setId(int i) {id = i;}public int getId() {return id;}
}
UML类图
统一建模语言
1、this;
2、继承性
3、super
4、多态：继承性的延续；
This
This：
在这里表示的就是对象；可以调用成员变量和方法；
场景：
- 1、声明set方法时，通过形参给对应的属性赋值；如果形参和类中属性同名；
- 2、构造器内，调用正在构建的类内的数和方法；重载多个构造器内调用封装的方法；
一般情况下会省略this.;
我就是不省略；–为了和js同步；
***** 构造器不能添加修饰符；
This();
//可以调用类中的其他构造器；
//必须写在构造器中的首行；
//每个构造器中最多声明一个；
class Person {
int age;
String name;public Person() {System.out.println(this.age);this.setAge(14);}public Person(String name) {this();this.name = name;}public Person(int age) {this("lucy");this.age = age;}public void setAge(int age) {age = age;System.out.println("age:" + age);//13System.out.println("this_age:" + this.age);//0/* 赋值失败，就近原则。形参给形参赋值，赋了个寂寞 */}}
如果一个类型有多个构造器，那么类中最多有n-1个构造器；
否则会搞出死循环；
继承
- 1、从上而下：extends
- 2、自下而上：
- ruguo发现多个类相似很多，搞一个父类；
***继承都有一个is-a的关系；cat is-a animal；不能为了继承而继承；
格式：
class A{
}
class B extends A{
}
class C extends A{
}
子类获取了父类的所有属性和方法；同时在堆内存中，子类的内存中也有父类的属性和方法；
***虽然继承了，但是父类的私有属性及方法，子类中还是不能用；
Extends 延伸，扩展，延展；子类继承过来之后可以功能更强大；
默认父类;：java.lang.Object;
a.getClass().getSuperclass()
System.out.println(a.getClass().getSuperclass());//class java.lang.Object
//一个父类可以有多个子类；
public class Person {int age;String name;public void sleep() {System.out.println("sleep");}public void eat() {System.out.println("person_eat");}public Person() {System.out.println("null");}public Person(int age) {System.out.println("age");}
}
public class Student extends Person {int age;String school;public void eat() {System.out.println("sutdent_eat");}public void sleep() {System.out.println("student_sleep");}public void show() {super.eat();this.eat();eat();//省略this；}public void getAge() {System.out.println(age);System.out.println(super.age);System.out.println(this.age);//省略this；}public Student () {super(3); //nullSystem.out.println("student_null");//student_null}public Student(int age) {this();System.out.println("student_age"); //father_null;student_age;}
}
public static void main(String[] args) {Student st1 = new Student();st1.show();st1.age = 10;st1.getAge();Student st2 = new Student(1);}
重写
Overwirte、override；
子类可以使用父类的方法，但是又不那么合适；可以考虑使用；
定义：
子类对父类继承过来的方法进行覆盖、覆写；
- 调用子类方法时，调用的就是子类重写后的方法；
权限修饰符 返回值类型 方法名（形参）[throw 异常类型] {方法体}
@Override
protected Object clone() throws CloneNotSupportedException {return super.clone();
}
规则：
- 1、方法名和形参列表必须一致；
- 2、子类重写的权限修饰符不得小于被重写的修饰符；public>protected>default;;
- (1)特例；如果父类是private，子类则不能重写(子类也看不到了）；
- 3、返回值类型
- (1)如果父类是void，则子类必须也是void；
- (2)如果父类的返回值基本数据类型，则子类必须和父类相同；
- (3)如果父类的返回值是引用类型，则子类可以和父类相同、或者返回父类的引用类型的子类类型；
- 4、子类重写之后抛出的异常，可以和父类相同，也可以是子类的类型；
一般来说子类就和父类保持一致；
Super
理解为父类的。。。；
为什么要用？
- 1、子类重写父类，子类还需要调用父类中被重写的方法；
- 2、子类继承父类以后，子类和父类定义了同名属性；—属性不存在覆盖的说法；
如何使用
super.eat();
Super可以调用的结构：
1、属性、方法、构造器；
例子：
1、方法
This不加super：依次寻找自己-父类-父类。。。。。。。。。；找到Object为止；
2、属性；
public void getAge() {
System.out.println(age);
System.out.println(super.age);
System.out.println(this.age);//省略this；
}
、、、重名尽量避开，可读性太差；
3、构造器：
子类继承父类的时候是不会继承构造器的；
public Student () {
super(); //null
System.out.println("student_null");//student_null
}****super（）必须写在首行，和this();只能存在一个；
在构造器中：如果什么都没写，父类中默认调this();子类中默认调super();
public Student(int age) {
System.out.println("student_age"); //father_null;student_age;(默认调用父类空参构造器）
}**如果不写空参构造器，有参构造器会覆盖空参构造器；此时子类构造器会报错；
正因为调用过父类的构造器，所以才会把父类的属性方法加载到子类的内存中供子类使用；
子类实例化的过程；
This
- 可以调用的 结构
- 1、属性、
- 2、方法、
- 3、构造器；
- 1和2中可以理解为当前对象中；
- 3中理解为当前正在创建的对象；可以调用其他重载的构造器；构造其中不声明默认调 super();
继承:
- 继承性、
- 1、好处：减少冗余；提高复用性； 提高扩展性；为多态的使用提供了前提；
- 2、局限性：单继承性。
- 多态性
- 封装性；
重写：override
1、
Super：父类的；
- 1、属性： super.xxx; ===> 子父类有权限且同名参数时使用；
- 2、方法 super.xxx(); ===》子类重写了父类方法后，需要调用父类方法时；
- 3、构造器 super(1); 子类构造器中首行必然super、this二选一；
public static void main(String[] args) {Student st1 = new Student();st1.show();st1.age = 10;st1.getAge();Student st2 = new Student(1);}
--Spark 简介)
、循环语句(while、do while、for、范围for)、跳转语句、try语句块和异常处理)
)
