java基础学习笔记 - 面向对象课时1
作者：互联网
p67 封装详解
1、封装的好处：
1）程序设计要追求“高内聚 低耦合”，高内聚就是类的内部数据操作细节自己完成，不许外部干涉；低耦合即仅暴露少量的方法给外部使用
2）复杂性封装，只对外提供简单的操作入口， 隐藏代码的实现细节，看不到实物复杂的那一面，只展示事物简单的一面
3）封装之后形成真正的“对象”，真正的“独立体”，增强了系统的可维护性
4）封装之后提高了代码的安全性，保护了数据
5）封装意味着有统一接口，程序可以重复使用，适应性强
2、封装的实现：属性私有-get/set
1）类的所有属性私有化，外部程序不能直接访问，使用private关键字修饰，private修饰的数据只能在当前类中访问
2）对外提供简单的操作入口，以后外部程序想要方问对象，必须通过这些简单的入口进行访问：
- 对外提供两个公开的方法作为入口，get/set方法
- set/get方法必须是 public修饰的
- 调用set方法修改属性，set方法只负责修改数据，没有返回值，通过传参修改实例变量的值
- 调用get方法读取属性，有返回值类型，get方法负责返回该类型的数据
- 可以在get/set的方法体中进行安全过滤
3、get/set 的语法：
public 返回值类型 getName(){return field;}
public void setName(形参){ }
public returntype getName(){
return field; }
public void setName(type variable){
this.field = value;
... ... }
//示例3-1
public class D03{
public static void main(String[] args){
Student s = new Student();
//通过方法传参设置值
s.setName("小明",13,'男');
//打印返回的数据
System.out.println(s.getName());
System.out.println(s.getAge());
System.out.println(s.getSex());
}
}
//Student类
public class Student{
//属性私有
private String name;
private int age;
private char sex;
//提供一些可以操作类的属性的方法
//提供一些 public的 get、set方法
//给数据设置值
public void setName(String name,int age,char sex){
this.name = name;
this.age = age;
this.sex = sex;
}
//获取这个数据
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public char getSex(){
return this.sex;
}
}
View Code
//示例3-2：构造器测试，重载，get/set测试
//构造器类
public class Constructor{
public static void main(String[] args){
//调用无参构造
Account act1 = new Account();
//通过入口访问对象的属性
System.out.println("账号：" + act1.getActno());
System.out.println("余额：" + act1.getBalance());
//调用有参构造
Account act2 = new Account("110",10000);
//访问对象的属性
System.out.println("账号：" + act2.getActno());
System.out.println("余额：" + act2.getBalance());
//通过入口修改对象的属性
act2.setActno("act-110");
act2.setBalance(200000);
System.out.println("账号：" + act2.getActno());
System.out.println("余额：" + act2.getBalance());
}
}
//定义账户类
public class Account{
private String actno;
private double actbalance;
//构造方法重载
//构造方法初始化实例变量手动或默认
public Account(){
//actno = null;
//actbalance = 0.0;
}
public Account(String s){
actno = s;
//actbalance = 0.0;
}
public Account(double d){
//actno = null;
actbalance = d;
}
public Account(String s, double d){
actno = s;
actbalance = d;
}
//访问入口get/set
public String getActno(){
return actno;
}
public void setActno(String actno){
this.actno = actno;
}
public double getBalance(){
return actbalance;
}
public void setBalance(double balance){
this.actbalance = balance;
}
}
View Code
p68 继承 extends关键字
- 继承是类和类之间的一种关系，此外类和类之间的关系还有依赖、组合、聚合等
- 继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
- 继承关系的两个类，子类是派生类，父类的基类
- 子类继承父类，子类是父类的扩展，子类拥有父类的全部的属性和方法
- java中类只有单继承没有多继承，一个子类只能继承一个父类，一个父类可以扩展多个子类
- java中所有的类都默认继承 Object类
public class 子类名 extends 父类名{ }
2、有 final 修饰的类将不能被继承
如：pubic final class person{} //该类将不能被继承
示例4:
public class D04{
public static void main(String[] args){
Student student = new Student();
student.say(); //说了一句话
System.out.println(student.money); //10_0000_0000
}
}
//Person类
public class Person{
public int money = 10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
}
//Student类
public class Student extends Person{}
View Code
p70 重写override
1、重写与父类引用的逻辑
- 在继承关系中，子类可以重写父类的方法，属性不存在重写
- 重写的方法通常是非静态的、public的
- 父类型的引用可以指向子类对象，但子类的引用不能指向父类对象
- 父类型的引用指向子类对象，相当于创建了一个新的隐藏的子类型的对象，但它没有该子类的元素，而是只继承父类的所有属性和方法，被重写的方法在这里被覆盖，因此通过父类引用调用重写的方法，相当于调用了子类的方法，父类引用也无法真正访问子类对象
- 如果重写的方法是静态的，父类的引用仍然调用父类的方法，静态的方法无法被重写
2、重写的语法
- 重写的方法名、参数列表都必须相同
- 重写的方法体不同，执行的功能不同
- 修饰符：范围可以扩大但不能缩小 public>protected>default>private
- 抛出的异常：范围可以被缩小但不能扩大 ClassNotFoundException < Exception
3、为什么需要重写
- 父类的功能，子类不一定需要或者不一定满足
4、以下情况不能重写：
- static 修饰的方法
- private 修饰的方法
- final 定义的常量
//示例7-1：重写静态方法的调用
public class T07{
public static void main(String[] args){
A a = new A();
B b = new A();
a.test(); //相当于A.test();
b.test(); //相当于B.test();
}
}
//子类重写父类的方法
public class A extends B{
public static void test(){
System.out.println("A=>test()");
}
}
//父类
public class B{
public static void test(){
System.out.println("B=>test()");
}
}
View Code
//示例7-2：重写非静态方法的调用
public class T07{
public static void main(String[] args){
A a = new A();
B b = new A();
//非静态方法的重写，通过引用调用的方法是对象的方法
a.test(); //A=>test()
b.test(); //A=>test()
}
}
//子类重写
public class A extends B{
public void test(){
System.out.println("A=>test()");
}
}
//父类
public class B{
public void test(){
System.out.println("B=>test()");
}
}
View Code
//示例7-3：重写的辩证 父类引用指向子类对象的情况
public class T07{
public static void main(String[] args){
//非静态方法的重写
A a = new A();
B b = new A(); //相当于隐藏创建了一个父类对象
//重写方法时，父类的引用默认调用子类的方法
a.test(); //A=>test()
b.test(); //A=>test()
//显示创建父类对象，调用被重写的父类方法
B c = new B();
c.test(); //b=>test()
//不能调用子类独有的方法
//b.test1();
//可以访问父类的属性 、方法
System.out.println(b.name);
b.test2();
}
}
//子类继承父类
public class A extends B{
//重写方法
public void test(){
System.out.println("A=>test()");
}
//独有方法
public void test1(){
System.out.println("A1=>test()");
}
}
//父类
public class B{
String name;
public void test(){
System.out.println("B=>test()");
}
public void test2(){
System.out.println("B2=>test()");
}
}
View Code
p71 多态：
- 多态是方法的现象，属性没有多态性
- 多态存在于有继承关系的类中，父类引用指向子类对象
- 一个对象的实际类型是确定的，但指向它的引用的类型可以有多个父类类型
- 子类能调用的方法都是它自己的或者继承父类的
- 父类型的引用可以指向子类对象，但是不能调用子类独有的属性和方法，只能调用子类重写的方法
- 用强制转换类型的办法，使父类引用s2的类型降级，就可以得到一个指向子类对象的子类引用，这时该引用可以完全访问子类对象
例：Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
((Student)s2).eat();
//示例8：
//测试类
public class T08{
public static void main(String[] args){
//指向对象的引用类型是多种的
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
s1.run(); //Student run
//子类重写了父类run()方法，S2默认调用子类的方法
s2.run(); //Student run
//s2不能调用子类独有的方法
//s2.eat();
//用强制转换类型的办法，使s2类型降级，可以访问子类对象，可能会丢失什么
((Student)s2).eat();
}
}
//子类
public class Student extends Person{
//重写run()方法
public void run(){
System.out.println("Student run");
}
//子类的独有方法
public void eat(){
System.out.println("Student eat");
}
}
//父类
public class Person{
public void run(){
System.out.println("Person run");
}
}
View Code
//即使再小的帆也能远航2021-11-13
标签：java,子类,void,课时,面向对象,test,父类,重写,public 来源： https://www.cnblogs.com/hongmeiaoxue/p/15549169.html