类
封装
-
该露的露，该藏的藏
程序设计要追求“高内聚，低耦合“。
高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅暴露少量的方法给外部使用。
-
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
-
记住：属性私有，get/set
//类 private:私有 与 public对应
/*
* 1.提高程序的安全性，保护数据
* 2.隐藏代码的细节
* 3.统一接口
* 4.增加系统可维护性
* */
public class Dome04 {
//定义一个学生类 有姓名，年龄，学号 三个属性 定义一个方法，学习。
private String name; //属性一般使用 private
private int age;
private int id;
//提供一些可以操作这个属性的方法 提供一些public的 get、set方法
//get 获得这些数据 set 给这些数据设置
public String GetName(){
return this.name; //通过 GetName 方法进行name的获取
}
public void SetName(String name){
//使用封装能进行一些非法性的判断条件增加
this.name = name; //通过 SetName 对对象的name属性进行设置。
}
}
继承
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
-
extends 的意思 “扩展”。子类是父类的扩展
-
java中类只有单继承，没有多继承
-
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。
-
继承关系的两个类，一个为子类（派生类）一个为父类（基类）。子类继承父类，使用关键字 extends来表示
-
继承的写法
// Dome05 继承了 Dome04 关键字 ： extends 继承 public class Dome05 extends Dome04 { // Dome05继承 Dome04 public static void main(String[] args) { Dome05 dome05 = new Dome05(); dome05.GetName(); // 因为及承诺了 Dome04的关系，所以new出来的05也继承了 //Dome04中的GetName方法 } } -
子类和父类之间，从意义上来讲应该具有 is a 的关系
-
object类
java中 所有的类 都默认直接或间接继承了 object
-
super 详解
super 代表父 this 代表子 私有的属性无法继承
public class Dome06 extends Dome04 { private String name; // Dome06私有的 name属性 //在 Dome04中，定义了 protected String name; public void test(String name){ System.out.println(name); //这里打印的是传参进来的name System.out.println(this.name); //这里打印的是 Dome06 自己私有的 name System.out.println(super.name);// 这里打印的是 Dome04 父类中定义的 name } }注意点，1.super调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和 this不能同时调用构造方法
vs this
代表的对象不同
this 本身调用者这个对象
super 代表父类对象的应用
前提
this 没有继承也可以使用
super 只能在继承条件下才能使用
构造方法
this（） 本类的构造
super（） 父类的构造
-
方法重写
重写都是方法的重写，与属性无关
方法重载 和 方法重写 是不一样的
注意点：
重写方法只能是 public
重写方法不能使用static静态
小结：
重写方法：
需要有继承关系，子类重写父类的方法：
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 public > Protected >Default >private
4.抛出的异常:可以被缩小，但不能扩大。ClassNotFoundException --> Exception（大） 这样是不行的
重写：子类的方法和父类必须一致：方法体不同
为什么要重写：
1.父类的功能，子类不一定需要或者不一定满足。
Alt + Insert 选中override
举例：
public class Dome07_A {// Dome07_A中有方法 test() public void test(){ // 不能使用static静态方法 System.out.print("Hello"); } }public class Dome07_B extends Dome07_A { //Dome07_B继承了07_A public static void main(String[] args) { //方法的调用只和左边定义的数据类型有关 //静态方法和非静态方法区别很大 //使用了static静态方法，只和左边定义的数据类型有关 //重写，只跟非静态方法有关。 Dome07_A dome07_a = new Dome07_B(); // 此时虽然 new的也是 dome07_B dome07_a.test(); //但是 此时的 dome07_a 执行的是子类 B的test方法 //如果 方法加了static 变成了静态，这里会调用父类的test（）方法 } @Override public void test(){ System.out.println("Hello World"); } }
修饰符
- public 要被继承的方法一般使用 public
- private //私有不能继承
- default
- protected //受保护的
- static 加了就是静态
public class Dome09 {
//静态代码块 是用来初始化一些东西的，new一个对象就会执行
// static是最早执行的，其次是匿名代码块，最后才是构造方法
{ //赋初始值
//匿名代码块
System.out.println("匿名代码块");
}
static { //只执行一次
//静态代码块
System.out.println("静态代码块");
}
public Dome09(){
//构造方法
System.out.println("构造方法");
}
public static void main(String[] args) {
Dome09 dome09 = new Dome09();
}
}
静态导入包
import static java.lang.Math.random;
再次调用Math.random() 方法就可以直接使用 random()了
多态
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
-
多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象
-
注意：
1.多态是方法的多态，属性没有多态性
2.父类和子类 有联系，类型转换异常 ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
子类没有的执行父类 子类有的方法执行子类
4.不能重写的方法：
1.static 方法，属于类，它不属于实例
2.final 常量
3.private方法
-
instanceof 类型转换---- 引用类型
instanceof （类型转换----引用类型）
instanceof 判断一个对象的类型
语法：
对象名 instanceof 类型名 ===> 返回布尔值
类型之间的转换 父 子
低转高 自动转换
高转低 强制转换 (低类型)高类名
子类转换为父类，可能丢失自己的本来的一些方法
举例：
Student 继承了 Person类， obj对象需要调用 student类中的方法go，需要进行强制转换
Person obj = new Student();
((Studen) obj).go();
小结：
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型，强制转换（可能丢失方法）
- 方便方法调用，减少重复代码
抽象类
- abstract 修饰符 可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
- 抽象类中可以没有抽象方法，但是有抽象方法的类，一定要声明为抽象类
- 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
- 抽象方法，只能方法的声明，没有方法的实现，它是用来让子类实现的。
- 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
//abstract 抽象类 类 extends 单继承 （接口可以多继承）
public abstract class Dome10 {
//约束~有人帮我们实现~
//abstract 抽象方法，只有方法名字，没有方法的实现。
public abstract void doSomething();
//1. 不能new 这个抽象类，只能靠子类去实现它，约束
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中。
}
接口
声明类的关键字是 class
声明接口的关键字是 interface
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有
- 接口：只有规范！ 自己无法写方法~专业的约束，约束和实现分离。
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是汽车，则必须能跑。
- 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
- OO的精髓，是对对象的抽象，最能体现这一点的就是接口
package oop;
//interface 定义的关键字，接口都需要有实现类
public interface Dome11 {
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void del(String name);
}
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承 可以利用接口实现多继承
public class Dome11impl implements Dome11,Dome12{
@Override
public void add(String name) {
}
@Override
public void del(String name) {
}
@Override
public void update() {
}
@Override
public void find() {
}
}
小结：
作用：
- 约束
- 定义一些方法，让不同的人实现~
- public abstract
- public static final
- 接口不能被实例化~接口中没有构造方法
- implements关键字可以实现多个接口
- 必须要重写接口中的方法
内部类
- 内部类就是在一个类的内部在定义一个类，比如A类中定义B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
一个java类中可以有多个class类，但只能有一个 public class类
-
成员内部类
-
静态内部类
-
局部内部类
-
匿名内部类
没有名字初始化类，不用将实例保到变量中。
public class Dome13 {
public static void main(String[] args) {
Dome13 dome13 = new Dome13();
//通过这个外部类来实例化内部类；
Dome13.Inner inner = dome13.new Inner();
inner.in();
}
private int id;
public void out(){
System.out.println("外部类的方法");
}
class Inner{
public void in(){
//可以获得外部类的私有属性，方法
System.out.println("内部类的方法");
}
}
}
82
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
