java面向对象编程基础——狂神说Java基础笔记

2022-11-21 14:35:37

一、面向对象编程概念

1、面向对象思想

2、什么是面向对象？

本质：以类的方式组织代码。以对象组织封装数据。

3、回顾方法及加深

1、方法定义回顾：

package com.oop.demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }

    // String:返回一个字符串
    public String sayHello(){
        return "Hello";   // return代表方法结束，返回一个结果
    }

    //void:返回一个空值
    public void hello(){
        return;
    }

    //int:返回一个整数
    public int max(int a, int b){
        return a > b ? a : b;
    }

    //读文件  抛出异常
    public void readFile(String file) throws IOException{

    }
}

2、静态方法和非静态方法的调用区别：

package com.oop.demo01;

public class Student {

    // 静态方法
    public static void say(){
        System.out.println("学生说话了");
    }

    // 非静态方法
    public void hello(){
        System.out.println("你好啊");
    }
}

package com.oop.demo01;

public class Demo02 {

    public static void main(String[] args) {
        // 静态方法 static
        Student.say();
        // 非静态方法
        Student student = new Student();
        student.hello();
    }

}

3、static方法不能调用不是静态方法的方法：

package com.oop.demo01;

public class Demo02 {

    public static void main(String[] args) {}
    // static 和类一起加载
    public static void a(){
        b();
        // 报错 Non-static method 'b()' cannot be referenced from a static context
    }
    // 类实例化之后才存在
    public void b(){}
}

4、形参和实参

package com.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        // 实参形参类型一致
        int sum = demo03.add(2,3);
        System.out.println(sum); //5
    }

    public int add(int a, int b){
        return a+b;
    }
}

5、java都是值传递

package com.oop.demo01;

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

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

6、引用传递

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); // NULL
        Demo05.change(person);
        System.out.println(person.name); // liuting
    }

    //返回值为空
    public static void change(Person person){
        //person是一个对象：指向的 Person person = new Person()；这是一个具体的人，可以改变属性。
        person.name = "liuting";
    }

}

//定义了一个Person类，有一个属性name
class Person{
    String name;
}

二、类与对象

1、类与对象的关系

2、创建与初始化对象

package com.oop.demo02;

//一个项目只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的--->实例化
        //实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student liuting = new Student();
        Student kuangsheng = new Student();
		
        //对象1
        liuting.name = "liuting";
        liuting.age = 18;
        System.out.println(liuting.name);
        System.out.println(liuting.age);

		//对象2
        kuangsheng.name = "kuangsheng";
        kuangsheng.age = 3;
        System.out.println(kuangsheng.name);
        System.out.println(kuangsheng.age);
    }
}

package com.oop.demo02;

// 学生类
public class Student {
    // 属性：字段
    String name; //null
    int age; //0

    //方法
    public void study(){
        System.out.println(this.name + "在学习");
    }
}

3、构造器

一个类即使什么都不写，它会存在一个方法。

package com.oop.demo02;

public class Person {

    public Person() {
    }
}

作用1：使用new关键字，本质就在调用构造器。
作用2：初始化值

测试：

package com.oop.demo02;

//一个项目只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //实例化一个对象
        Person person = new Person();
        System.out.println(person.name);//liuting
    }
}

package com.oop.demo02;

public class Person {
    String name;
    //一个类即使什么都不写，它会存在一个方法
    //显示的定义构造器

    //实例化初始值
    //1、使用new关键字，本质就在调用构造器
    //2、初始化值
    public Person(){
        this.name = "liuting";
    }

}

有参构造: 一旦定义了有参构造，无参构造就必须显示定义。

快捷键：Alt+Insert自动生成构造器

构造器总结：
1、和类名相同
2、没有返回值

作用：
1、使用new关键字，本质就在调用构造器
2、初始化值

注意点：定义有参构造之后，如果想使用无参构造，无参构造就必须显示定义
this. = 传进来的值；

package com.oop.demo02;

public class Person {
    //一个类即使什么都不写，它会存在一个方法
    String name;
    int age;
    //显示的定义构造器

    //实例化初始值
    //1、使用new关键字，本质就在调用构造器
    //2、初始化值
    public Person(){

    }

    //有参构造:一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        //this. = 当前对象传进来的值；
        this.name = name;
    }

    //快捷键：Alt+Insert自动生成构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 测试：
/*
    public static void main(String[] args) {

        //实例化一个对象
        Person person = new Person("kuangsheng",23);
        System.out.println(person.name);//kuangsheng
    }
 */
/*
总结：
    构造器：
    1、和类名相同
    2、没有返回值
    作用：
    1、使用new关键字，本质就在调用构造器
    2、初始化值
    注意点：定义有参构造之后，如果想使用无参构造，无参构造就必须显示定义
    快捷键：
    Alt + Inter
    this. = 当前对象传进来的值；

 */

4、内存图示

5、总结

三、封装

意义：

1、提高程序的安全性

2、隐藏代码的实现细节

3、统一接口

4、系统可维护性增加了

package com.oop.demo03;

// 类  private:私有
/*
意义：
    1、提高程序的安全性
    2、隐藏代码的实现细节
    3、统一接口
    4、系统可维护性增加了
 */

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int Age;

    // 提供一些可以操作这个属性的方法！ get/set
    // public 的 get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    //快捷键：Alt+Insert


    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){
            this.Age = 3;
            System.out.println("年龄不合法");
        }else {
            this.Age = age;
        }

    }
}

测试：

package com.oop;

import com.oop.demo03.Student;

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

        s1.setAge(999);  //不合法
        System.out.println(s1.getAge());
    }
}

四、继承

子类继承了父类，就会拥有父类的全部方法。

在java中，所有的类都默认直接或间接的继承object类

Person父类：

package com.oop.demo04;

//父类
public class Person /*extends Object*/ {
    public int money1  = 10_0000_0000;
    private int money2  = 20_0000_0000;

    public void say(){
        System.out.println("hello");
    }

    public int getMoney2() {
        return money2;
    }

    public void setMoney2(int money2) {
        this.money2 = money2;
    }
}

Student子类：

package com.oop.demo04;

//子类 ---学生 is 人
//子类继承了父类，就会拥有父类的全部方法。
public class Student extends Person {

    //快捷键： Ctrl + H
}

Teacher子类：

package com.oop.demo04;

//子类 ---老师 is 人
public class Teacher extends Person{
}

测试：

package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say(); //hello
        System.out.println(student.money1); //10_0000_0000
        //System.out.println(student.money2);//父类 private 不能继承
    }
}

1、super、this

私有的东西无法被继承！

super注意点：

父类：

package com.oop.demo05;

//父类
public class Person /*extends Object*/ {

    public Person() {
        System.out.println("Person无参构造执行了");
    }

    protected String name = "父类的名字";

    public void print(){
        System.out.println("Person");
    }
}

子类：

package com.oop.demo05;

//子类 ---学生 is 人
//子类继承了父类，就会拥有父类的全部方法。
public class Student extends Person {
    //无参
    public Student() {
        //隐藏代码，调用了父类的构造器
        super(); //调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student无参构造执行了");
    }

    //有参
    public Student(String name) {
        this.name = name;
    }

    private String name = "子类的名字";

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();
        this.print();
        super.print();

    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }
}

测试：

package com.oop;

import com.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        /*
            Person无参构造执行了
            Student无参构造执行了
         */
        student.test("传递的名字");
        /*
            传递的名字
            子类的名字
            父类的名字
         */
        student.test1();
        /*
            Student
            Student
            Person
         */
    }
}

2、方法重写

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

父类的引用指向子类是可以的

方法的调用只和左边的相关，即定义的数据类型有关

package com.oop.demo05;
//重写都是方法的重写，和属性无关
public class B {
    public static void test(){
        System.out.println("B->test");
    }
}

package com.oop.demo05;

//重写都是方法的重写，和属性无关
public class A extends B {
    public static void test(){
        System.out.println("A->test");
    }
}

test:

package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

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  类的优先级比对象大
    }
}

快捷键：Alt + Insert—>Override Method

静态的方法和非静态的方法区别很大

package com.oop.demo05;
//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B->test");
    }
}

package com.oop.demo05;

//重写都是方法的重写，和属性无关
public class A extends B {
    @Override//重写 有功能的注释
    public void test() {
        System.out.println("A->test");
    }
}

test:

package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {
    //静态的方法和非静态的方法区别很大
    public static void main(String[] args) {

        // 方法的调用只和左边的相关
        A a = new A();
        a.test(); //A->test

        // 父类的引用指向子类是可以的
        B b = new A();// 子类重写了父类的方法
        b.test(); //A->test
    }
}

3、重写总结：

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

方法名必许相同
参数列表必须相同
修饰符：范围可以扩大但是不能缩小 (Public->Protect->Default->Private)
抛出的异常：范围可以缩小但是不能扩大；

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

为什么需要重写？

父类的功能不一定需要
父类的功能不一定满足

五、多态

####1、实例

package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("father");
    }
}

package com.oop.demo06;

public class Student extends Person {
    @Override  //子类重写
    public void run() {
        System.out.println("sun");
    }
	// 子类独有的方法，父类不能调用
    public void eat(){
        System.out.println("eat");
    }
}

test：

package com.oop;

import com.oop.demo06.Person;
import com.oop.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();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.run(); //sun
        s2.run(); //sun子类重写了父类的方法，执行子类的方法
        s1.eat(); //eat
        
        //错误 父类可以指向子类，但是不能调用子类独有的方法
        //s2.eat()
    }

}

####2、多态的注意事项

多态是方法的多态
父类和子类，有联系类型转换异常ClassCastException！
存在条件：继承关系，方法需要重写
父类引用指向子类对象

####3、不能进行重写、多态

static方法：属于类，不属于对象
final 常量
private方法：私有的

4、instanceof

X instanceof Y：用X和Y是否是父子关系来判断是否能编译通过。

package com.oop.demo07;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

package com.oop.demo07;

public class Student extends Person{
  
}

package com.oop.demo07;

public class Teacher extends Person{
}

package com.oop;

import com.oop.demo07.Person;
import com.oop.demo07.Student;
import com.oop.demo07.Teacher;

public class Application {
    public static void main(String[] args) {

        //Object->Person->student
        //Object->Person->teacher
        //Object->String
        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

        Person person = new Student();
        System.out.println("============================");
        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); //编译报错

        Student student = new Student();
        System.out.println("============================");
        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(student instanceof String); //编译报错
    }
}

5、总结

一个对象的实际类型是确定的，可以指向的引用类型就不确定了
//new Student(); 确定的
//new Person(); 确定的

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
子类能够调用的方法只有自己的或者继承的
父类可以指向子类，但是不能调用子类独有的方法
父类/接口变量名 = new 子类/实现类();
Person s2 = new Student(); //父类的引用指向子类
多态：父类的变量指向子类对象

条件：

父类引用指向子类的对象
把子类转换为父类，向上转型，会丢失一些方法
把父类转换为子类，向下转型，需要强制转换，
方便方法的调用，减少重复的代码。

六、static

####1、static变量、方法

static 跟类一起产生
静态方法不能调用非静态方法，非静态方法可以调用静态方法
类可以直接调用静态static变量和static方法
类的对象可以调用static和非static方法和变量

例一：

package com.oop.demo08;

// static   跟类一起产生
public class Student {
    
    private static int age; //静态变量
    private double score; //非静态的变量
    
    //静态方法
    public static void run(){
        System.out.println("run");
        // go();  静态方法不能调用非静态方法
    }
    
    //非静态方法
    public void go(){
        System.out.println("go");
        run(); //非静态方法可以调用静态方法
    }

    
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println(Student.age); //类直接调用
        //System.out.println(Student.score); //false

        s1.run();
        s1.go();
        Student.run();
        //Student.go;  false类不能直接调用

        run();
        //go(); //false

    }
}

2、static代码块

静态代码块：跟类一起产生，永久只执行一次
匿名代码块跟对象同时产生
先执行静态代码块，再执行匿名代码块，再执行构造方法

例二：

package com.oop.demo08;

public class Person {
    // 2 跟对象同时产生，可以给对象赋初值
    {
        //代码块(匿名代码块)
        System.out.println("匿名代码快");
    }

    // 1:执行一次
    static{
        //静态代码块，永久只执行一次
        System.out.println("静态代码快");
    }

    // 3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=============");
        Person person2 = new Person();
    }
}

//运行结果：
/*
静态代码快
匿名代码快
构造方法
=============
匿名代码快
构造方法
 */

3、静态导入包

例三：

package com.oop.demo08;

//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

七、抽象类

总结1

abstract抽象方法，只有方法名字，没有方法的实现；有人帮我们实现。
抽象类的所有方法，继承了他的子类，都必须要实现它得方法。
继承了抽象类的子类，必须实现父类的所有抽象方法。
类只能单继承，但是接口相当于多继承（接口多实现）。

总结2

不能new抽象类，只能靠子类去实现它：约束
抽象类里面可以有普通方法
抽象方法必须在抽象类中
抽象的抽象：约束~
存在构造器么？存在的意义？提高开发效率

实例

package com.oop.demo09;

//abstract:抽象类
public abstract class Action {

    //约束~ 有人帮我们实现
    //abstract:抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
}

package com.oop.demo09;

//抽象类的所有方法，继承了他的子类，都必须要实现它得方法
public class A extends Action{
    @Override
    public void doSomething() {
    }
}

八、接口

接口自己无法写方法，是专业的约束！约束和实现分离：面向接口编程~

作用

接口是一个约束
定义一些方法，让不同的人实现
接口中的方法：public abstract
接口中的常量：public static final
接口不能被实例化~接口中没有构造方法
implements可以实现多个接口
必须要实现接口中的方法

实例

接口1：

package com.oop.demo10;

// interface定义的关键字，接口都需要有实现类

public interface UserService {

    //常量(全局性的)

    public static final int AGE1 = 99;
    //相当于
    int AGE2 = 99;

    //接口中的所有定义都是抽象的public

    public abstract void add(String name);
    //public abstract可以省略
    public abstract void delete(String name);
    public abstract void update(String name);
    public abstract void query(String name);

}

接口2：

package com.oop.demo10;

public interface TimeService {
    void timer();
}

test:

package com.oop.demo10;

// 一个类可以实现接口 implements： 接口
// 实现了接口的类，就需要实现接口中的方法~

//利用接口可以实现伪多继承
public class UserServiceImp1 implements UserService,TimeService {

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

九、内部类

一个java类中可以有多个class类，但是只能有一个public class类

package com.oop.demo11;

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    // 内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //内部类获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

    //一个java类中可以有多个class类，但是只能有一个public class类
    class A{
        public  void main(String[] args) {
            System.out.println();
        }
    }

    //局部内部类
    public void method(){
        class Inner{
          public void in(){

          }
        }
    }
}

test：

package com.oop;

import com.oop.demo11.Outer;


public class Application {
    public static void main(String[] args) {

        //new 外部类
        Outer outer = new Outer();
        outer.out();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

package com.oop.demo11;

public class Test {
    public static void main(String[] args) {
        
        // 没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();
        
        // 必须重写
        UserService userService = new UserService(){
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

//接口：
interface UserService{
    void hello();
}

码农公寓

一、面向对象编程概念

1、面向对象思想

2、什么是面向对象？

3、回顾方法及加深

二、类与对象

1、类与对象的关系

2、创建与初始化对象

3、构造器

4、内存图示

5、总结

三、封装

四、继承

1、super、this

2、方法重写

3、重写总结：

五、多态

4、instanceof

5、总结

六、static

2、static代码块

3、静态导入包

七、抽象类

总结1

总结2

实例

八、接口

作用

实例

九、内部类

相关文章