Java学习笔记——面向对象

最新推荐文章于 2024-08-24 17:09:16 发布

__________习惯

最新推荐文章于 2024-08-24 17:09:16 发布

阅读量247

点赞数 1

分类专栏： java 文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/l903445981/article/details/125887673

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、什么是面向对象

面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的三大特性：封装、继承、多态

二、方法调用

1.静态方法调用

类名+方法名

public class Student{
	//静态方法
	public static void say(){
		System.out.println("学生在讲话");
	}
	public static void main(String[] args){
		Student.say();
		say();
	}
}

注意：因为在同一个类下，所以也可以直接写方法名。

2.非静态方法调用

实例化类+方法名

public class Student{
	//非静态方法
	public void say(){
		System.out.println("学生在讲话");
	}
	public static void main(String[] args){
		Student student = new Student();
		student.say();
	}
}

3.补充：static关键词

1>带有static关键词的方法或者变量可以直接通过类名+方法名/变量名获取

public class Demo01 {
    private static String name = "Lihua";
    private double score = 88.8;

    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
        System.out.println(Demo01.name);
        System.out.println(demo01.name);
        System.out.println(demo01.score);
    }
}

2>带有static关键词的方法或变量是与类一起加载的

public class Demo02 {

    public static void a(){

    }
    
    public void b(){
        a();
    }
}

因为方法a()是和类一起加载的，所以方法b()里可以直接调用a()

public class Demo02 {

    public static void a(){
    	b();  //报错
    }
    
    public void b(){
       
    }
}

因为方法b()在类实例化之后才存在，所以在方法a()里调用方法b()会报错。
3>静态代码块只执行一次

public class Demo03 {
    //2 作用：赋初值
    {
        System.out.println("匿名代码块");
    }
    //1 只执行一次
    static{
        System.out.println("静态代码块");
    }

    //3 
    public Demo03(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        new Demo03();
        System.out.println("------------------");
        new Demo03();
    }
}

输出：

静态代码块
匿名代码块        
构造方法
------------------
匿名代码块        
构造方法

4>静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Demo04 {
    
    public static void main(String[] args) {
        System.out.println(random()); //0.13545342469787336
        System.out.println(PI);       //3.141592653589793
    }
}

三、Java是值传递

1.一个方法不能修改一个基本数据类型的参数

public class Demo01 {
    
    public static void change(int a ){
        a = 10;
    }

    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);  //1
        change(a);
        System.out.println(a);  //1

    }
}

2.一个方法可以改变一个对象参数的状态

public class Demo02 {
    public static void main(String[] args) {
        Student student1 = new Student("小明");
        Student student2 = new Student("小红");

        //⼀个⽅法可以改变⼀个对象参数的状态。
        Demo02.swap1(student1, student2);  
        System.out.println("-----------------------------");
        System.out.println(student1.name);  //小红
        System.out.println(student2.name);  //小明
    }

    public static void swap1(Student student1,Student student2){
        String temp = student1.name;
        student1.name = student2.name;
        student2.name = temp;
        System.out.println("-----------swap1-------------");
        System.out.println(student1.name);  //小红
        System.out.println(student2.name);  //小明
    }
}

class Student{
    String name;
    int age;
    public Student(String name){
        this.name = name;
    }
}

3.一个方法不能让对象参数引用一个新的对象

public class Demo03 {
    public static void main(String[] args) {
        Student student1 = new Student("小明");
        Student student2 = new Student("小红");

        //⼀个⽅法不能让对象参数引⽤⼀个新的对象
        Demo03.swap2(student1, student2);
        System.out.println("-----------------------------");
        System.out.println(student1.name);  //小明
        System.out.println(student2.name);  //小红
    }

    public static void swap2(Student student1,Student student2){
        Student temp = student1;
        student1 = student2;
        student2 = temp;
        System.out.println("-----------swap2-------------");
        System.out.println(student1.name);  //小明
        System.out.println(student2.name);  //小红
    }
}

class Student{
    String name;
    int age;
    public Student(String name){
        this.name = name;
    }
}

四、继承

Java中类只有单继承，没有多继承！可以简单理解为：一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子。

public class Demo01 {
    
}

class Person{
    private int money= 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}
//子类继承父类，就会拥有父类的全部方法
class Student extends Person{

}
class Teacher extends Person{
    
}

继承关系：Object -> Person -> Student
继承关系：Object -> Person -> Teacher
说明：在Java中，所有的类都直接或间接继承Object

补充：this与super

1.变量

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("蒲荷");
    }    
}

class Person{
    protected String name = "LanTian";
}
//子类继承父类，就会拥有父类的全部方法
class Student extends Person{
    private String name = "Puhe";
    public void test(String name){
        System.out.println(name);  //蒲荷
        System.out.println(this.name); //Puhe
        System.out.println(super.name); //LanTian
    }
}

2.方法

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test();
    }    
}

class Person{
    protected String name = "LanTian";
    public void print(){
        System.out.println("Person");
    }
}
//子类继承父类，就会拥有父类的全部方法
class Student extends Person{
    private String name = "Puhe";
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();      //Student
        this.print(); //Student
        super.print();//Person
    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test();
    }    
}

class Person{
    protected String name = "LanTian";
    //私有的东西无法被继承!!!!!!!!!!!!!!!
    private void print(){
        System.out.println("Person");
    }
}
//子类继承父类，就会拥有父类的全部方法
class Student extends Person{
    private String name = "Puhe";
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();      //Student
        this.print(); //Student
        super.print();//报错!!!!!!!!!!!!!!
    }
}

3.构造方法

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }    
}

class Person{
    public Person(){
        System.out.println("Person无参执行了");
    }
    protected String name = "LanTian";
    public void print(){
        System.out.println("Person");
    }
}
//子类继承父类，就会拥有父类的全部方法
class Student extends Person{
    public Student(){
        //隐藏代码，调用了父类无参构造器
        super(); //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
    private String name = "Puhe";
    public void print(){
        System.out.println("Student");
    }
}

输出

Person无参执行了
Student无参执行了

4.总结

1>super注意点
      ①super调用父类的构造方法，必须在构造方法的第一个
      ②super必须只能出现在子类的方法或者构造方法中！
      ③super和this不能同时调用构造方法
2>super与this的区别
代表对象
      this:本身调用者这个对象
      super:代表父类对象的引用
前提
      this:没有继承也可以使用
      super:只能在继承条件下使用
构造方法
      this:本类的构造
      super:父类的构造

五、多态

1.理解重写

重写静态方法。方法的调用只和左边定义的数据类型有关。

import java.security.PublicKey;

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

重写非静态方法。

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

总结
重写：需要有继承关系，子类重写父类的方法
      1.方法名必须相同
      2.参数列表必须相同
      3.修饰符：范围可以扩大但不能缩小：public > protected > default > private
      4.抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException --> Exception(大)
为什么需要重写？
      父类的功能，子类不一定需要，或者不一定满足！

2.多态实例

import java.security.PublicKey;

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.eat() //报错，eat()为子类中独有的方法
        s1.eat();  //eat
    }
}
class Student extends Person{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
class Person{

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

多态注意事项
      1.多态是方法的多态，属性没有多态
      2.父类和子类，有联系；类型转换异常时会报ClassCastException
      3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();
补充不能重写的情况
      1.static方法，属性类，它不属于实例
      2.final，常量
      3.private方法

3.补充instanceof

1>原理说明
X instanceof Y
首先，看编译能否通过。如果X和Y存在联系，则编译通过。

//例如，存在这样的继承关系，Object - > Person -> Student和Object - > Person -> Teacher
Person p = new Student();   
System.out.println(p instanceof Teacher);//是可以编译通过的,因为p的类型是Person，而Person和Teacher是存在关系的。

然后，看X指向的实例对象是不是Y的子类或父类，然后判断对错；如果X指向的实例是Y的子类或同一个类，返回true；

//比如，还是上文的继承关系
Object object = new Student()
System.out.println(object instanceof Person);//返回true因为Student是Person的子类
System.out.println(object instanceof Student);//返回true，因为Student跟Student是同一个类。

如果X指向的实例是Y的父类，或者没有继承关系;

Object object = new Person();
System.out.println(object instanceof Student);//返回false，因为Person是Student的父类；
Person person = new Student();
System.out.println(person instanceof Teacher);//返回false，因为Student和Teacher没有继承关系。

2>例子

public class Test {
    public static void main(String[] args) {
        //Object -> String
        //Obeject -> Person -> Student
        //Obeject -> Person -> Teacher
        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);   //编译不通过
        System.out.println("----------------------------");
        Person person1 = new Person();
        System.out.println(person1 instanceof Student);  //false
        System.out.println(person1 instanceof Person);   //true
        System.out.println(person1 instanceof Object);   //true
        System.out.println(person1 instanceof Teacher);  //false
        // System.out.println(person1 instanceof String);   //编译不通过
        System.out.println("----------------------------");
        Person p = new Student();
        System.out.println(p instanceof Teacher);  //false
        Object o = new Person();
        System.out.println(o instanceof Student);  //false
    }
}

class Person{

}

class Student extends Person{
    
}

class Teacher extends Person{

}

类型之间的转化
子类转换为父类，可能会丢失自己本来的一些方法！

六、抽象类与接口

1>抽象类

//类extends，单继承，接口可以多继承
public abstract class Action {
    
    //abstract,抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它
    //2.抽象类中可以写普通的方法和抽象方法
    //3.抽象方法必须在抽象类中
    //4.抽象类可以有构造器，需要通过构造链来调用
}

2>接口
接口的定义

public interface UserService {
    
    //常量：默认使用public static final修饰
    int AGE = 99;

    //接口中定义的所有方法默认使用public abstract修饰
    void add();
    void delete();
    void update();
    void query();
}

接口的实现

public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        // TODO Auto-generated method stub

    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void update() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void query() {
        // TODO Auto-generated method stub
        
    }
    
}