封装
- 该露的露,该藏的藏
- 高内聚,低耦合
- 封装(隐藏的数据)
- 通常,应该禁止直接访问一个对象中的数据实际表示,而应该通过接口来访问,这称为信息隐藏
- **记住这句话就够了:属性私有,get/set **
package Demo3;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("pofen");
s1.setAge(9);
System.out.println(s1.getName());
System.out.println(s1.getAge());
s1.Study();
}
}
package Demo3;
public class Student {
//private 属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;
//学习()
//睡觉()
//提供一个可操作性的方法
//提供一些public 的get,set方法
//get 获得这个数据
public void Study(){
System.out.println(name+"在学习");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0){
this.age = 3;
}else {
this.age = age;
}
}
}
//set 给这个数据设置值
- Alt+insert :自动生成set/get方法
pofen
9
pofen在学习
- 封装的作用
- 提高程序的安全性,保护数据
- 隐藏代码的细节
- 统一接口
- 系统可维护增加了
继承
- 继承的本质是对某一批类的抽象,从而事项对现实世界更好的建模
- extends的意思是“扩展”。子类是父类的扩展
- JAVA中只有单继承单继承,没有多继承(一个儿子只有一个类,一个类可以有多个儿子)
- 继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖,组合,聚合等
- 继承的关系是两个类,一个子类(派生类),一个为父类(基类)。子类继承父类,使用extends表示
- 子类和父类之间,意义上将应该应具有“is a"关系
- object类
- super
- 方法重写
package Demo4;
public class Student extends Person{
}
package Demo4;
//person 人 父类
public class Person {
//public 公共的
//private 私有的
public int money = 10_0000_0000;
public void say(){
System.out.println("说了破风真帅");
}
}
package Demo4;
public class teacher extends Person{
}
package Demo4;
public class teacher extends Person{
}
-
person 人 父类
-
学生 is 人 :派生类 ,子类
-
子类继承了父类,就会拥有父类的全部方法
-
Ctrl+H:会打开一个继承树列表
-
在JAVA中,所有的类都默认直接或者间接继承object类
super
package Demo4;
public class Student extends Person{
private String name = "poFenx";
public void test(String name){
System.out.println(name);//波哥
System.out.println(this.name);//poFenx
System.out.println(super.name)//pofen
}
}
package Demo4;
//person 人 父类
public class Person {
protected String name ="pofen";
}
package Demo4;
public class Application {
public static void main(String[] args){
Student student= new Student() ;
student.test("波哥");
}
}
Application
package Demo4;
public class Application {
public static void main(String[] args){
Student student= new Student() ;
// student.test("波哥");
// student.test1();
}
}
Student
package Demo4;
public class Student extends Person{
private String name = "poFenx";
public void print(){
System.out.println("Student");
}
//隐藏代码;调用了父类的无参构造
//调用父类构造器,必须要在子类构造器的第一行
//this也要在第一行
public Student(){
super();//有参调用有参数,如果不写默认调用无参
System.out.println("Student无参构造执行了");
}
public void test1(){
print();//Sutdent
this.print();//Student
super.print();//Person
}
public void test(String name){
System.out.println(name);//波哥
System.out.println(this.name);//poFenx
System.out.println(super.name);//pofen
}
}
Person
package Demo4;
//person 人 父类
public class Person {
public Person(){
System.out.println("Perosn无参构造执行了");
}
protected String name ="pofen";
public void print(){
System.out.println("Person");
}
}
super Vs this
- super小结
- super调用父类的构造方法,必须在构造的第一个
- super必须只能出现在之类的方法或者构造方法中
- super和this不能同时调用构造方法,因为他们要调用的话必须都都放在第一行
-
super Vs this
代表对象不同
this:本身调用者这个对象:谁调用就是谁
super:代表父类对象的引用
前提
this :没有继承(extends)也可以使用
super:只能在继承条件下才能使用
构造方法
this()本类构造
super() 父类构造
方法从写
-
重写
需要有继承关系,而且是子类重写父类的方法,不能重写属性
-
方法名必须相同
-
参数列表必须相同,否则就是重载了,而且重载是当前方法
-
修饰符:范围可以扩大:public>protected>Default>private
-
抛出异常:范围可以被缩小,但是不能扩大classNotfoundException–>Exception(大)
重写:子类的方法和父类必须要一致,方法体不同。
为什么需要重写:
-
父类的功能子类不一定需要,或不一定满足
Alt+Insert+override :重写
Application
package Demo4;
public class Application {
//非静态 重写
//静态方法和非静态方法的区别很大
//加了static是静态方法
/*静态(static)方法是类的方法,非静态(无static)的方法是对象的方法
没有static时,b调用的是对象的方法,而b是用A类new的
有static时,b调用了B类的方法,因为b是用B类定义的
即b是A new出来的,因此调用了A的方法
*/
//方法的调用只和左边,定义的数据类型有关
public static void main(String[] args){
//方法的调用只和左边,定义的数据类型有关
A a =new A();
a.test();
//父类的引用指向子类
B b = new A();//字类重写了父类的方法
b.test();
}
}
A
package Demo4;
//继承
public class A extends B {
//Overide 重写
@Override//注解,有功能的注解
public void test() {
System.out.println("A=>test()");
}
}
// public void test(){
// System.out.println("A=>test()");}
B
package Demo4;
//从写都是方法的从写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
多态
-
动态编译:类型:可扩展型
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象实际类型是确定的,但可以指向对象的引用类型有很多(父类,关系的类)
-
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向对象
-
注意:多态是方法的多态,属性没有多态
-
instanceof :类型转换 引用类型的转换
多态的注意事项
-
多态是方法的多态,属性没有多态
-
父类和子类,有联系,类型转换异常,不能瞎转换 ClassCastException!:类型转换异常(看到这个说明父子类之间出现了一些问题
-
存在的条件: 继承关系,方法的重写
-
父类的引用指向指向子类对象 Father f1 = new Son();
有序方法不能被重写
- static 方法 属于类 ,他不属于实例
- final 常量
- private 方法:
Application
package Demo5; public class Application { public static void main(String[] args) { // new Student(); // new Person(); //一个对象的实际类型是确定的 :比如说都是Student //可以指向的引用类型是不确定的 :Student s1,Person s2,Object s3 /*Student能调用的方法都是自己的,或者继承父类的! */ Student s1 = new Student(); //Person 父类型,可以指向子类,但是不能调用子类独有的方法 Person s2 = new Student();//父类的引用指向子类 Object s3= new Student(); s2.run();//子类重写了父类的方法,执行子类的方法 s1.run();//看类型,哪一个类型就执行谁的,两个类型都有的时候就执行子类的了 ((Student) s2).eat();//类型强制转换 //对象能执行那些方法,主要看对象左边的类型,和右边关系不大 /*s2.eat();person中没有person方法,会报错,所以调用不了, 如果person与Student都有,只要子类没有重写父才调用父类, 重写了的话就是子类 */ } }
Student
package Demo5;
public class Student extends Person {
public void run(){
System.out.println("son" );
}
public void eat(){
System.out.println("eat");
}
}
Person
package Demo5;
public class Person {
public void run() {
System.out.println("run");
}
}