Day15–01
P66 面向对象07:简单小结类与对象
/*
总结 类与对象:
1、类是一个模板,类是抽象的,对象是一个具体的实例
方法:
1、定义和调用
对象的引用:
引用类型: 八大基本类型(byte short int long float double char boolean)
对象是通过引用来操作的:栈--->堆
属性:字段Field 成员变量
默认初始化:
数字:0 0.0
char: u0000
boolean: false
引用类型: null
修饰符 属性类型 属性名 = 属性值
对象的创建和使用
必须使用new 关键字创建对象,构造器 Person kuangshen = new Person();
调用对象的属性: kuangshen.name
调用对象的方法: kuangshen.sleep()
类包含的:
静态的 属性
动态的 方法
*/
P67 面向对象08:封装详解
快捷键:alt + ins 快速生成get set 方法,如下图
代码
以下两个代码是互动的,一个是main启动程序,一个是类
package com.oop.demo04;
//类 private:私有
public class Student {
//属性私有
private String name;//名字//前面加private,把这个属性name私有
private int id;//学号
private char sex;//性别
private int age;
//private私有这些属性后无法像以前一样直接对象调用这些属性
//提供一些可以操作这个属性的方法
//提供一些public 的 get set 方法
//get 获得这个数据 (获取哪个数据方法名就用get啥啥 如这里的getName)
public String getName(){ //我们写一个公共的方法来获取加private的name这个数据
return this.name; //在另一个程序里用 s1.getName();回车 来获取name这个数据
//就不能像之前用s1.name;回车 来获取name数据了
}
//set 给这个数据设置值 (给啥啥数据设置值 方法名就用set啥啥 如这里的setName)
public void setName(String name){
this.name = name;//this.的意思是this所在的当前这个页面Student
//这个类,等于把外界赋给形参String name的值 赋与给当前类中的this.name
// (也是当前Student类中的private String name;中的这个name赋值)
}
//这里用快捷键alt+insert快速生成其他几个private变量的set和get方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120 || age<0){//如果输入的年龄数字大于120或者小于0,我们输出3
this.age = 3; // || 或的意思,前后有一个为真就返回真,全false才返回false
}else {
this.age = age;
}
}
}
package com.oop.demo03;
import com.oop.demo04.Student;
public class Application {
//进入了main方法
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("张三");
System.out.println(s1.getName());//输入s1.getName().sout按回车 快捷键输出
//输出:张三
s1.setAge(-1);//在setAge方法里输入值-1,经过判断输出age=3
System.out.println(s1.getAge());//输出3
}
}
/*
封装的意义:
1、提高程序的安全性,保护数据
2、隐藏代码的实现细节,比如s1.setAge(-1);这里用户只能去设置括号里面的数,
但类的方法里面的细节用户就不知道了
3、统一接口 即所有的方法都是get和set,形成了一个规范
4、提高系统的可维护性
5、set方法里经常会对输入的数据进行一个安全性的判断,比如上边的setAge()
方法,里面就有一个对用户输入的数值进行的一个大于120或小于0的判断
*/
P68 面向对象09:什么是继承
注意:PPT里的是extends,写错成了extands
下面四个程序是互动的,一个main程序Application,一个父类Person,两个子类Student和Teacher
//在这个main类里面 new 了Student的对象
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.money);
Person person = new Person();
}
}
//Person 总的类 是父类
//在Java中,所有的类,都默认继承Object类 ctrl+h打开等级列表显示当前类继承关系
package com.oop.demo05;
public class Person/* extends Object */ {
//修饰符protected
//修饰符public:公共的 如果想让子类继承父类数据就加public
//修饰符private:私有的
//修饰符default:默认的,即前边不加修饰符时 为这个状态
public int money = 10_0000_0000;
//这里用了public修饰符
//如果父类用了private而不是public,则子类无法调用父类的方法
public void say(){
System.out.println("说了一句话");
}
}
//派生类,相当于Person程序的子类
package com.oop.demo05;
//student is person 派生类,相当于Person程序的子类
//子类Student继承了父类Person,就会拥有父类Person的全部方法,可直接调用
public class Student extends Person {//在public class Student后
//加了extends Person 就成为了Person的子类,就是继承了Person类
}
//派生类,相当于Person程序的子类
package com.oop.demo05;
//派生类,相当于Person程序的子类
public class Teacher extends Person{
}
P69 面向对象10:Super详解
下面四个程序是互动的,一个main程序Application,一个父类Person,两个子类Student和Teacher
//在这个main类里面 new 了Student的对象
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("秦疆");
/*输出:秦疆
qinjiang
kuangshen
*/
student.test1();
/*输出:Student
Student
Person
*/
}
}
//派生类,相当于Person程序的子类
package com.oop.demo05;
//student is person 派生类,相当于Person程序的子类
//子类Student继承了父类Person,就会拥有父类Person的全部方法,可直接调用
public class Student extends Person {
//这是个子类构造器
public Student() {
//这里有隐藏代码:调用了父类的无参构造
super();//调用父类的构造器,必须要在子类构造器的第一行
System.out.println("Student无参构造器执行了");
}
private String name = "qinjiang";
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();//表示调用的父类Person里的print方法
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);//表示输出父类Person里的name
}
}
//Person 总的类 是父类
//在Java中,所有的类,都默认继承Object类 ctrl+h打开等级列表显示当前类继承关系
package com.oop.demo05;
public class Person/* extends Object */ {
//这是个父类构造器
public Person() {
System.out.println("Person无参构造器执行了");
}
protected String name = "kuangshen";
public void print(){
System.out.println("Person");
}
}
笔记
super注意点:
1、super调用父类的构造方法,必须在构造方法执行部分的第一行
2、super 必须只能出现在子类的方法或者构造方法中
(子类的构造方法中有一个隐藏的super调用了父类的构造方法)
3、super和 this 不能同时调用构造方法
super 比较 this:
代表的对象不同:
this:代表本身调用者这个对象
super:代表父类对象的应用
使用的前提:
this:没有继承也可以使用
super:只能在继承条件下才可以使用
调用构造方法的区别:
this():调用本类的构造
super():调用父类的构造
P70 面向对象11:方法重写
笔记:
重写override的前提:需要有继承关系,子类重写父类的方法。override有覆盖覆写的意思
重写的两个方法特点:
1.方法名必须相同
2.形参参数列表必须相同
3.修饰符:范围可以扩大但不能缩小: public>protected>default>private
4.抛出的异常:范围,可以被缩小,但不能扩大 ClassNotFoundException --> Exception(大)
重写,子类的方法名和父类必须一致,方法体不同
为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足
alt+insert:选中override;
//在这个main类里面 new 了的对象
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
//静态的方法和非静态的方法区别很大
//加了static的静态方法:方法的调用只和等号左边的东西有关 ,左边定义的数据类型有关
//非静态方法(不加static):重写
//重写的方法的关键词不能是private
//重写是子父类之家才有的,是子类重写(覆写)了父类的方法
A a = new A();
a.test();//
//父类的引用指向了子类
B b = new A();//子类A重写了父类的方法
b.test();//
}
}
package com.oop.demo05;
public class A extends B{
@Override
//注解:有功能的注释! override重写,覆写的意思
public void test() {
System.out.println("A=>test()");
}
}
package com.oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}