!! 有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);}