学习总结

面向对象

面向过程思想：

步骤清晰简单，第一步做什么，第二部做什么......

面对过程适合处理一些较为简单的问题

属性 + 方法：变成一个类

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。

最后，才对某个分类下的细节进行面向过程的思考。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍需要面向过程的思路去处理。

什么是面向对象

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

抽象

三大特性：

1. 封装

2. 继承

3. 多态

   从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

   从代码运行的角度考虑是先有类后有对象。类是对象的模板。

break和return的区别

break：跳出switch，结束循环

return：代表方法结束，返回一个结果。return的返回值必须和返回类型相同

//Demo01  类
public class Demo01 {
    //main  方法
    public static void main(String[] args) {
​
    }
​
    /*
    修饰符     返回值类型      方法名（）{
        //方法体
        return  返回值;
    }
     */
    public String sayHello(){
        return "Hello,world!";
    }
​
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b;//三元运算符！
    }
​
}

引用传递和值传递区别

值传递：实参传递给形参的是值 形参和实参在内存上是两个独立的变量 对形参做任何修改不会影响实参

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
​
        Demo04.change(a);
​
        System.out.println(a);
    }
    //返回值为空
    public static void change(int a){
        a = 10;
​
    }
}

引用传递：实参传递给形参的是参数对于 堆内存上的引用地址 实参和 形参在内存上指向 了同一块区域 对形参的修改会影响实参

//引用传递：传递一个对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
​
        System.out.println(perosn.name);//null
​
        Demo05.change(perosn);
        System.out.println(perosn.name);
    }
    public static void change(Perosn perosn){
        //perosn是一个对象：指向的 ---> Perosn perosn = new Perosn();这是一个具体的人，可以改变属性！
        perosn.name = "zgf";
    }
}
//定义了一个Perosn类，有一个属性：name
class Perosn{
    String name;
}

创建与初始化对象

使用new关键字创建对象

使用new关键词创建的时候，除了hui分配内存空间之外，还会给创建好的对象 进行默认的初始化以及对类中构造器的调用。

构造器必须掌握

//学生类
public class Student {
​
    //属性：字段
    String name;//默认：null
    int age;//默认：0
​
​
    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
    }
​
}
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
​
    //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
​
        Student xiaoming = new Student();
        Student xh = new Student();
​
        xiaoming.name = "小明";
        xiaoming.age = 3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
​
        xh.age = 3;
        xh.name = "小红";
​
        System.out.println(xh.name);
        System.out.println(xh.age);
​
    }
}

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装系统)数据。

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：

1. 必须和类的名字相同

2. 必须没有返回类型，也不能写void

快捷键创建：alt + lnsert 自动生成构造器

//java ---> class
public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    //显示的定义构造器
​
    String name;
​
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //2.构造器用来初始化值
    public Person(){
        this.name = "zgf";
    }
    //有参构造：一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }
}
/*
public static void main(String[] args) {
​
        //new 实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);
​
    }

    构造器：
    1.和类名相同
    2.没有返回值
    作用：
    1.new 本质在调用构造器
    2.初始化一些对象的值
    注意点：
    1.定义了有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
    快捷键：
       Alt + Insert
       this.：代表当前类
 

*/
public class Pet {
    public String name;
    public int age;
​
     //无参构造
​
    public void shout(){
        System.out.println("叫了一声");
    }
}
/*
public static void main(String[] args) {
​
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
 */
/*

1.  类与对象
    类是一个模板：抽象，对象是一个具体的实例
​
2.  方法
    定义、调用！
​
3.  对象的引用
    引用类型：   基本类型（八大基本类型）
    对象是通过引用来操作的：栈--->堆（地址）
​
4.  属性： 字段Field 成员变量
    默认初始化：
        数字：0    0.0
        char：   u0000
        boolean：    flase
        引用类型：   null
​
        修饰符     属性类型    属性名     =   属性值！
​
5.   对象的创建和使用
        -必须使用new 关键字创建对象，需要有构造器    Person zgf = new Person（）;
​
        -对象的属性  zgf.naeme
​
        -对象的方法  zgf.sleep()
​
6.  类：
    静态的属性   属性
​
    动态的行为   方法
 */

封装

该露的露，该藏的藏

程序设计要追求”高内聚，低耦合，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用。

属性私有，get/set

//类     private：私有
public class Student {
​
    //属性私有
    private String name;//名字
    private int id;//学号
    private char  sex;//性别
​
    //提供一些可以操作这个属性的方法！
    //提供一些public 的 get、set方法
​
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
​
    }
    //快捷键：alt + insert  自动生成get/set方法
​
}
/*

封装的意义
    1.提高程序的安全性，保护数据
    2.隐藏代码的细节
    3.统一接口
    4.提高了系统的可维护性
 

*/
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("zgf");
        System.out.println(s1.getName());
    }
}

继承

继承的本质是对某一批类的抽象

extands的意思是"扩展"。子类是父类的扩展

JAVA只有单继承，没有多继承

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键词extands来表示。

子类和父类之间，从意义上讲应该具有"is a"的关系

快捷键：ctrl+H 查看继承关系

在JAVA中，所有的类，都默认直接或者继承Object类

子类继承父类

//四个修饰符
//public公共的
//protected受保护的
//default默认的
//private私有的
//公共的子类可以继承父类

私有的东西无法继承

调用父类的构造器，必须在子类构造器的第一行。

this和super的区别

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中！

3. super和this不能同时调用构造方法！

    

   Vs this：

   代表的对象不同：

   this：本身调用者这个对象

   super：代表父类对象的应用

   前提

   this：没有继承也可以使用

   super：只能在继承条件下才可以使用

   构造方法

   this（）；本类的构造

   super（）；父类的构造

重写

重写都是方法的重写和属性无关

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private

4. 抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException：类找不到的异常

重写，子类的方法和父类的方法必须要一致；方法体不同！

为什么需要重写：

1. 父类的功能子类不一定需要或者不一定满足

alt + insert 选中override：重写；

import com.opp.demo05.A;
import com.opp.demo05.B;
import com.opp.demo05.Student;
​
public class Application {
    //静态方法和非静态方法区别很大！
    //静态方法： //方法的调用只和左边定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {
​
​
        A a = new A();//A
        a.text();
        //父类的引用指向了子类
        B b = new A();//B   子类重写了父类的方法
        b.text();
    }
}
/*
public class B {
​
     public  void text(){
         System.out.println("B-->text()");
     }
}
//继承
public class A extends B{
    //Override重写
    @Override//注解：有功能的注释！
    public void text() {
        System.out.println("A=>text");
    }
}
​
 */

多态

同一方法可以根据发送对象的不同而采取多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

多态的注意事项：

1. 多态是方法的多态，属性没有多态

2. 父类和子类，有联系 出错：（类型转换异常！）ClassCastException！

3. 多态存在的条件：继承关系，方法需要重写，父类引用指向子类对象！

import com.opp.demo06.Person;
import com.opp.demo06.Student;
​
public class Application {
    public static void main(String[] args) {
​
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了
​
        //Student   能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person    父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();//父类的引用指向子类
        Object s3 = new Student();
​
        //对象能执行那些方法。主要看对象左边的类型和右边关系不大
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}
/*
public class Person {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
}
 */

instanceof：

System.out.println(X instanceof Y);编译能不能通过，如果存在父子关系，则通过

类型转换

子类转化为父类，可能丢失自己本身的原来的一些方法！

 

1. 父类引用指向子类对象

2. 把子类转换为父类，向上转型；不用强制转换

3. 想把父类转化为子类，向下转型；需要强制转换，强制转换可能会丢失一些方法

4. 方便方法的调用，减少重复的代码

import com.opp.demo06.Person;
import com.opp.demo06.Student;
​
public class Application {
    public static void main(String[] args) {
        //类型之间的转化：基本类型转换    高低64 32 16高转低（强转）低转高不需要强转
        //父与子
        //高                    低
        Person obj = new Student();
        //student将这个对象转化为Student类型，我们就可以使用Student类型的方法了！
        Student obj1 = (Student) obj;
        obj1.go();
        ((Student) obj).go();
    }
}
/*
public class Person {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{
    public void go() {
    }
}
​
 */

static关键词详解

//static：
public class Student {
    private static int age;//静态的变量  多线程！
    private double score;//非静态的变量
​
    public void run(){
​
    }
    public static void go(){
​
    }
​
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
​
}


public class Preson {
    //第二个执行
    {
        //代码块（匿名代码块）（可以赋初始值）
        System.out.println("匿名代码块");
    }
    //第一个执行(只执行一次)
    static {
        //静态代码块
        
    }
    //第三个执行
    public Preson() {
        System.out.println("构造方法");
    }
​
    public static void main(String[] args) {
        Preson preson1 = new Preson();
        System.out.println("======================");
        Preson preson2 = new Preson();
​
    }
}

static特点

1.随着类的加载而加载 2.优先于对象存在 3.被类的所有对象共享（也就是说如果某个成员变量被所有对象共享，那么他就可以被定义为静态的），共性用静态，特性用非静态 4.可以通过类名调用

 

如果类被final定义那么这个类没有子类

 

//静态导入包

import static java.包.方法；

抽象类

abstarct修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象的方法；如果修饰类，那么该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

 

抽象类，不能使用new关键字来创建对象，它是用来让子类进行继承的。

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

 

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

//abstract  使用abstract修饰--->抽象类     entends：单继承~    想要多继承（接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract  抽象方法，只有方法名字没有方法的实现！
    public abstract void doSomething();
​
    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通方法！
    //3.抽象方法必须在抽象类中！
    //抽象的抽象：约束~
}
/*
//抽象类所有的方法，继承了它的子类，都必须要实现他的方法~除非~子类也用abstract修饰就让它的子类来实现
public class A extends Action{
    @Override
    public void doSomething() {
​
    }
}
 */

接口

接口：只有规范！可以实现约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则 ，体现了现实世界中“如果你是...则必须能...”的思想

接口的本质就是契约就像我们人间的法律。制定好后大家都遵守。

 

声明类的关键词是Class，声明接口的关键词的关键词是interface

接口的作用：

1. 约束

2. 让我们定义一些方法，让不同的人实现

3. 方法都是：public interfac
           public static final 常量

4. 接口不能被实例化，接口中没有构造方法

5. implements可以实现多个接口

6. 必须要重写接口中的方法

//  抽象类：extends
//  类 可以实现接口 implements一个接口
//  实现了接口的类，就需要重写接口中的方法
​
//多继承，利用接口实现多继承                 ()
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {
​
    }
​
    @Override//重写
    public void add(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
}
/*
// interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //接口中的所有定义的方法其实都是抽象的       默认 public abstract
​
    int age = 99;
​
    void add(String name);//增加
    void delete(String name);//删除
    void update(String name);//修改
    void query(String name);//查找
}
public interface TimeService {
    void timer();
}
 */