封装(student类)
/*
* 封装(属性私有,get/set):
* 我们的程序设计追求高内聚,低耦合,高内聚即类的内部数据操作细节自己完成,不允许外部干涉,低耦合即仅暴露少量的方法给外部使用
* 封装(数据的隐藏):一般禁止直接访问一个对象中数据的实际表示,而应该通过操作接口来访问,这称为信息隐藏。
*
* */
/*
* 继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模
* extends意思是扩展.子类是父类的扩展
* Java中类只有单继承,没有多继承;
* 继承是类与类之间的关系。除此之外,类和类直接的关系还有依赖,组合,聚合等;
* 继承关系的两个类,一个为子类(派生类),一个为父类(基类),子类继承父类,使用关键字extends来表示
* 子类和父类之间,从意义上讲应该具有“is a ”的关系
* ①Object类 ②super ③方法重写
* */
/*
* super注意点:
* 1.super调用父类的构造方法,必须在构造方法的第一个
* 2.super必须只能出现在子类的方法或者构造方法中
* 3.super 和 this不能同时调用构造方法;
* this:
* 代表的对象不同:this:代表本身调用者这个对象;super:代表父类对象的应用;
* 前提:this:没有继承也可以使用;super:只能在继承条件才可以使用;
* 构造方法:this:本类的构造;super:父类的构造
* */
/*
* 多态(是方法的多态,属性没有多态性):
* 动态编译
* 即同一方法可以根据发送对象的不同而采取多种不同的行为方式
* 一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
* 多态存在的条件:
* ①有继承关系 ②子类重写父类的方法 ③父类引用指向子类对象
* */
student类
/*
* 封装(属性私有,get/set):
* 我们的程序设计追求高内聚,低耦合,高内聚即类的内部数据操作细节自己完成,不允许外部干涉,低耦合即仅暴露少量的方法给外部使用
* 封装(数据的隐藏):一般禁止直接访问一个对象中数据的实际表示,而应该通过操作接口来访问,这称为信息隐藏。
*
* */
package com.Oop.Demo03;
public class Student {
/*封装的核心:私有
//名字 学号 性别 学习() 睡觉()
//属性私有
封装的好处:①提高程序安全性,保护数据;②隐藏代码的实现细节;③统一接口;④系统课维护性增加了
*/
private String name;
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法,public的get,set方法 alt+insert自动生成get set方法
//get获得这个数据
public String getName(){
return this.name;
}
public int getId() {
return id;
}
public char getSex() {
return sex;
}
//set给这个数据设置值
public void setName(String name){
this.name = name;
}
public void setId(int id) {
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 130 || age < 0){
this.age = 3;
System.out.println("不合法");
}else {
this.age = age;
}
}
}
继承(A继承B,Teacher继承Person)
Person类
package com.Oop.Demo03;
public class Person {
/*
* public:公共
* protected:
* default:
* private(属性私有,通过get,set方法调用):
* */
public Person(){
System.out.println("Person无参执行了");
}
protected String name = "qiqi";
private int money = 10_0000_0000;
public void say(){
System.out.println("说了句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
Teacher类
package com.Oop.Demo03;
//派生类
public class Teacher extends Person{
public Teacher(){
//隐藏代码:调用了父类的无参构造
super();//调用父类的构造器,必须要在子类构造器第一行
System.out.println("Teacher无参执行了");
}
private String name = "douzi";
//属性访问,方法类似
public void test(String name){
System.out.println(name);//传入的参数
System.out.println(this.name);//douzi
System.out.println(super.name);//super访问父类;父类Person中的qiqi
}
}
B类
package com.Oop.Demo03;
//重写都是方法的东西,与属性无关
public class B {
// public static void test(){
// System.out.println("B->test()");
// }//静态方法是类的方法
public void test(){
System.out.println("B->test()非静态");
}//非静态方法才是对象的方法
}
A类
package com.Oop.Demo03;
//继承关系
public class A extends B{
// public static void test(){
// System.out.println("A->test()");
// }//静态方法是类的方法
@Override//注解,有功能的注释
public void test() {
// super.test();
System.out.println("A->test()非静态");
}//非静态方法才是对象的方法
}
主方法
package com.Oop.Demo03;
public class Application {
public static void main(String[] args) {
/*
* ctrl + h:显示类的继承路径
* ctrl + f:全局搜索
* Java中所有的类默认
* 直接或间接继承Object
* */
Student s1 = new Student();
s1.setName("qiqi");
System.out.println(s1.getName());//println就是很多的方法重载(方法名相同,参数列表不同)
s1.setAge(999);
System.out.println(s1.getAge());//不合法 3
Teacher teacher = new Teacher();
teacher.say();//子类继承了父类就会继承了Person(父类)的全部方法
System.out.println(teacher.getMoney());
teacher.test("七七");
/*
* 快捷键:alt + insert :override
* 方法重写(需要有继承关系,子类重写父类的方法)
* 静态方法和非静态方法区别很大
* 即 b 是A new出来的对象,因此调用了A的方法
* 因为静态方法是类的方法,而非静态(才可以重写)是对象的方法(重点理解)
* 有static时,b调用了B类的方法,因为 b 是用B类定义的
* 没有static时,b调用的时对象的方法,而 b 时用类new的
* 1.方法名,参数列表必须相同(重写);方法名相同,参数列表不同(重载);
* 2.修饰符:范围可以扩大,但不能缩小 private->protected->default->public
* 3.抛出的异常:可以被缩小,不能被扩大
* 父类的功能不一定需要,或者不一定满足
* */
//静态方法的调用只和左边,定义的数据类型有关
A a = new A();
a.test();//有static时是A->test(),没有static时是A->test()非静态
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法,重写只和非静态相关
b.test();//有static时是B->test(),没有static时是A->test()非静态
}
}