08day
封装
高内聚，类的内部数据细节由自己完成，不允许外部干涉
低耦合，仅暴露少量的方法给外部使用
//demo04
public class Student {
//私有
private String name;
private int id;
private String sex;
private int age;
//提供可以使用这个属性的方法
//提供一些public的get/set的方法
//get得到这个数据
public String getName(){
return this.name;
}
//设置这个属性的值
public void setName(String name){
this.name=name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120||age<0){
System.out.println("您的信息出错");
this.age=3;
}else{
this.age = age;
}
}
}
//Application
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("王岩");
System.out.println(s1.getName());
s1.setId(1223);
System.out.println(s1.getId());
s1.setSex("man");
System.out.println(s1.getSex());
s1.setAge(999);
System.out.println(s1.getAge());
}
}
/*
1.提高程序安全性，保护数据
2.隐藏代码实现细节
3.统一接口
4.提高系统可维护性
*/
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends：扩展。子类是父类的扩展
Java类中只有单继承，没有多继承
-
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
-
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
-
子类和父类之间，从意义上将应该有“is a”的关系
//person
public class Person {
private int money=100000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
//CTRL+H查看继承结构
}
//Application
public class Application {
public static void main(String[] args) {
Person person = new Person();
Student student = new Student();
student.say();
student.setMoney(100);
System.out.println(student.getMoney());
}
}
super注意点：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类方法或者构造方法中
-
super和this不能同时调用构造方法
vs this：
-
代表对象不同：this本身调用这个对象；super代表父类对象的应用
-
前提：this没继承也可使用；super只能在继承条件中可以使用
-
构造方法：this（）：本类的构造；super（）：父类的构造
方法的重写
静态方法是类的方法，而非静态是对象的方法，有static时，b调用了B类的方法，因为b是用b类定义的，没有static是，b调用的是对象的方法，而b是用A类new出来的，即b是A new出来的对象，因此调用了A的方法。
重写和静态方法没关
重写的关键词只能是public而不能是private
重写：
-
需要有继承关系，而且是子类重写父类的方法
-
方法名必须相同
-
参数列表也必须相同
-
修饰符：范围可以扩大但不能缩小：public>protected>default>private
-
抛出的异常：可以被缩小，但不能被扩大
子类和父类的方法必须一致，方法体不同
为什么要重写？
-
父类的功能，子类不一定需要，或者不一定满足
-
Alt+Insert：Override
///A
public class A extends B{
//@Override重写
///B
public class B {
public void test() {
System.out.println("B=>test()");
}
}
//Application
public static void main(String[] args) {
A a= new A();
a.test();//调用A
//父类的引用指向子类
B b= new A();//子类重写了父类的方法
b.test();//调用B
}
多态
动态编译：类型（可扩展性）
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确认的，但可以指向对象的引用类型有很多
子类和父类都有一样的方法，调用父类的；
如果子类重写父类的，则调用子类
多态的注意事项：
-
多态是方法的多态，不是属性的
-
父类和子类，有联系 类型转换异常 ClassCastException
-
存在的条件：继承的关系，方法需要重写，（父类也有子类也有执行子类的）父类的引用指向子类对象 Father f1 = new Son（）;
不能被重写：static静态方法 属于类 不属于实例
final常量，无法改变
private方法
//Person
public class Person {
public void run(){
System.out.println("start");
}
}
//Student
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
//Application
public class Application {
//静态方法和非静态方法差别很大
//如果是静态方法，方法的调用只和左边定义的数据类型有关
public static void main(String[] args) {
//一个对象上的实际类型是确认的
Student s1 = new Student();//Student能调用的是自己的和父类继承来的
//但是可以指向的引用类型就不确定了 父类的引用指向子类
//引用类型 //实际类型
Person s2 = new Student();//Person 父类型 可以指向子类 但是不能调用子类独有的方法
Object s3 = new Student();
//对象执行哪些方法，主要看对象左边的类型，和右边关系不大
s2.run();//son
s1.eat();//eat
//强制转换类型
((Student)s2).eat();//eat
}
}
浙公网安备 33010602011771号