-
oop面向对象编程，oo面向对象
-
属性+方法=类
面向过程&面向对象
-
面向过程思想
步骤清晰简单
适合处理一些较为简单的问题
-
面向对象思想
-
分类思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思考
-
适合处理复杂的问题，和需要多人协作的问题
-
面向对象的本质：以类的方式组织代码，以对象的组织封装数据
-
抽象：剥离共同点
-
三大特性：
封装：将数据封装起来，留一个接口用于使用
继承：子类和父类
多态：同一事物多种形态
-
从认识论：对象是具体的事物；类，是抽象的，是对对象的抽象
-
从代码运行角度：先有类后有对象。类是对象的模板
创建和初始化对象
-
一个项目应该只存在一个main方法
-
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
-
特点：
必须和类的名字相同
必须没有返回类型，也不能写void
-
作用：
实例化初始值
使用new关键字，本质是在调用构造器
-
无参构造 例：public Person(){}
-
有参构造：一旦定义了有参构造，无参就必须显示定义
public Person（String name）{this.name=name;}
-
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
-
-
一个类什么都不写，也会存在一个方法（无参构造）
快捷键：Alt+insert 生成构造器
java中规定，双引号括起来的字符串是不可变的，也就是String类不可变，直接存储在"方法区"的字符串常量池
静态方法和类一起加载
总结
-
类与对象
类是一个模板：抽象 对象是一个具体的实例
-
方法的定义和调用
-
对象的引用
引用类型：
基本类型（8）
对象是通过引用来操作的：栈(引用变量)--->堆(对象)
-
属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char: u0000
boolean: false
引用：null
修饰符 属性类型 属性名 = 属性值
-
对象的创建和使用
-必须使用new 关键字创建对象，构造器 Person person = new Person（）
-对象的属性 person.name
-对象的方法 person.sleep()
-
类：
静态的属性 属性
动态的行为 方法
封装
-
高内聚，低耦合 高内聚是类的内部数据操作细节自己完成，不允许外部干涉 低耦合：仅暴露少量的方法给外部使用
-
属性私有，get/set
-
意义：
-
提高程序的安全性，保护数据
-
隐藏代码的实现细节
-
统一接口 get/set
-
系统可维护性增加
-
public class Case2 {
//属性：字段 私有
private String name;
private int id;
private char sex;
public String getName(){
return this.name;
}
public void setName(String name)
{
this.name=name;
}
public Case2() {
}
public Case2(String name) {
this.name = name;
}
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 static void main(String[] args) {i0
Case2 c1 = new Case2();
c1.setName("jah");
c1.setId(1);
c1.setSex('男');
System.out.println(c1.getName());
System.out.println(c1.getId());
System.out.println(c1.getSex());
}继承
-
继承的本质是对某一批类的抽象从而实现对现实世界更好的建模
-
extends的意思是拓展 子类对父类的拓展
-
Java中只有单继承没有多继承 一个子类只有一个父类，一个父类可以有多个子类
-
继承是类与类之间的一种关系 除此之外，类与类之间的关系还有依赖、组合、聚合等
-
继承关系的两个类，一个是子类（派生类），一个是父类（基类） 子类继承父类，使用关键字extends来表示
-
子类和父类之间，从意义上讲应该具有“is a”的关系 例：父类是person ，子类是学生 学生is person
-
在类中 Ctrl + H查看当前类的父类和子类
-
在Java中，所有的类，都默认直接或间接继承object类
super类与this
-
super注意点：
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
-
-
this：
-
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
-
前提：
this：没有继承也可以使用
super：只能在继承条件下才可以使用
-
构造方法
this（）：本类的构造
super（）：父类的构造
-
//父类
public class Person {
protected String name = "khk";
public void print(){
System.out.println("Person");
}
public Person() {
System.out.println("person无参执行");
}
}
//子类
public class Student extends Person{
private String name = "qinjiang";
public Student() {
super();//调用父类的构造器（隐藏代码，默认调用） 必须在子类构造器第一行
System.out.println("student无参执行");
}
public void test(String name){
System.out.println(name);//主函数调用时传递的参数
System.out.println(this.name);//当前类定义的
System.out.println(super.name);//父类定义的
}
public void print(){
System.out.println("student");
}
public void test1(){
print();//调用当前类
this.print();//调用当前类
super.print();//调用父类
}
}
//主函数
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("欢呼");//欢呼 qinjiang khk
student.test1();//student student Person
}
}方法重写
重写都是方法的重写，和属性无关
重写与静态方法无关，重写与非静态方法有关
重写的关键词只能是public
//静态方法
//父类
public class B {
public static void test(){
System.out.println("B=>test()");
}
}
//子类
public class A extends B{
public static void test(){
System.out.println("A=>test()");
}
}
//主函数
public class Application {
public static void main(String[] args) {
//方法的调用只和左边定义的数据类型有关
A a = new A();
a.test();//A=>test()
//父类的引用指向子类
B b = new A();
b.test();//B=>test()
}
}//非静态方法
//父类
public class B {
public void test(){
System.out.println("B=>test()");
}
}
//子类
public class A extends B{
-
重写：需要有继承关系，子类重写父类的方法
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大但不能缩小 public>protected>Default>private
-
抛出的异常：范围，可以被缩小，但不能扩大 ClassNotFoundException-->Exception(大)
-
-
重写，子类的方法和父类必须一致，方法体不同
-
重写的原因：父类的功能，子类不一定需要或不一定满足
-
快捷键Alt+Insert：override
多态
-
动态编译（类型）：通过多态使可扩展更好
-
同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（引用类型是指父类或者有关系的类）
-
多态存在的条件：
有继承关系
子类重写父类方法
父类引用指向子类对象
-
多态是方法的多态，属性没有多态性
//父类
public class Person {
public void run(){
System.out.println("son");
}
}
//子类
public class Student extends Person{
总结
-
多态注意事项：
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系 类型转换异常（非父子关系）：ClassCastException
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象
-
-
不能重写的：
-
static 方法，属于类，它不属于实例
-
final 常量
-
private 方法
-
-
instanceof (类型转换) 引用类型，判断一个对象是什么类型
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//False
System.out.println(object instanceof String);//False
System.out.println("==============");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//False
//System.out.println(person instanceof String);编译报错
System.out.println("==============");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);编译报错
//System.out.println(person instanceof String);编译报错
-
//子类转换为父类(自动转换)，可能丢失自己的本来的一些方法
Student student = new Student();
student.go();
Person person = student;
//高转低 强制转换
Person obj = new Student();
((Student) obj).go(); -
总结：
-
父类引用指向子类的对象 Person person = new Student();
-
把子类转换为父类，向上转型；低转高 自动转换；高转低 强制转换
-
把父类转换为子类，向下转型：强制转换
-
方便方法的调用，减少重复的代码！
-
-
