面向对象

最新推荐文章于 2024-10-07 21:17:34 发布

阿鬼大大

最新推荐文章于 2024-10-07 21:17:34 发布

阅读量142

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_50881929/article/details/113470796

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文深入解析了面向对象编程的核心概念，包括类与对象的创建、方法重写、继承性、多态性以及静态与非静态方法的区别。通过实例演示了如何使用new关键字、封装、继承和接口，以及Java中值传递与引用传递的区别。

摘要由CSDN通过智能技术生成

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

return和break区别

break：跳出switch语句和循环体

return：结束方法返回一个值可以为空，void没有返回值

方法名：驼峰命名，见名知意

静态方法和非静态方法区别

静态方法：通过其他类或者方法中可以直接调用

和类一起加载的

package OOP;

public class MethodStatic {
    public static void main(String[] args) {
        Student.Speak();
    }
}
class  Student{
    static void Speak(){
        System.out.println("学生说话");
    }
}

静态方法：需将类实例化后才能调用方法，类实例化后才会存在

package OOP;

public class MethodStatic {
    public static void main(String[] args) {
        Student student = new Student();
        student.Speak();
    }
}
class  Student{
     void Speak(){
        System.out.println("学生说话");
    }
}

值传递

package OOP;

public class demo01 {
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);
        add(a);
        System.out.println(a);
    }
    //java中是值传递，没有返回值的话，值是不变的，所以两次a打印结果都是1
    public static void add(int a){
        a =10;
    }
}

引用传递

package OOP;

public class Reference {
    //引用传递
    public static void main(String[] args) {
        student1 student1 = new student1();
        System.out.println(student1.name);//null
        Reference.change(student1);
        System.out.println(student1.name);//阿鬼大大
    }
    public static void change(student1 student1){
        student1.name = "阿鬼大大";
    }
}
class student1{
    String name;
}

类与对象的创建

package OOP;

public class TestClass {
    public static void main(String[] args) {
        Student1 Xiaoming = new Student1();
        Student1 Xiaohong = new Student1();
        Xiaoming.name = "小明";
        Xiaoming.age = 5;
        System.out.println(Xiaoming.name);
        System.out.println(Xiaoming.age);
        Xiaohong.name = "小红";
        Xiaohong.age = 5;
        System.out.println(Xiaohong.name);
        System.out.println(Xiaohong.age);


    }
}
class Student1{
    String  name;
    int age;
    void Study(String name){
        System.out.println(this.name+"爱学习");
    }
}

使用new关键字创建对象

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

使用new关键字，本质就是在调用构造器

构造器：和类名相同，且没有返回值

package OOP;

public class TestNew {
    public static void main(String[] args) {
        Student2 student2 = new Student2();
        System.out.println(student2.name);
        Student2 student21 = new Student2("王朝旭");
        System.out.println(student21.name);
    }
}
class Student2{
    String name;
    //在未定义无参构造时候，系统默认会生成一个无参构造器
    public Student2(){
        this.name = "阿鬼大大";
    }
    //一旦定义有参，无参必须定义，否则无效
    public Student2(String name){
        this.name = name;
    }
}

封装

package OOP;
 
public class Packaging {
    public static void main(String[] args) {
        Student3 student3 = new Student3();
        student3.setAge(100);

    }
}

class Student3{
    private String name;
    private  int age;
    public String setName(String name){
       return this.name = name;
    }
    public  int setAge(int age){
        if(age>0&&age<100)
        {
            return age;
        }
        else {
            System.out.println("有毛病？");
            return -1;
        }
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}

继承性

Java只有单继承，没有多继承
继承是类与类之间的一种关系，除此之外，还有组合，依赖，聚合等
继承关系的两个类，父类和子类

super

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的构造方法中
super和this不能同时调用构造方法

代表的的对象不同

this：本身调用这个对象
super：代表父类对象的应用

前提

this：没有继承也能使用

super:只能继承后才能使用

构造方法

this();本类的构造

super();父类的构造

package OOP;

public class ExtendsTest {
    public static void main(String[] args) {
        Students4 students4 = new Students4();
        //调用父类构造器super必须放在第一行

//        students4.test("王朝旭");
//        students4.test1();
    }
}

class Person {

    public   Person(){
        System.out.println("父类的构造方法");
    }
    String name = "阿鬼大大";
//私有的无法被继承
    void say() {
        System.out.println("person say");
    }
}

class Students4 extends Person {
    String name = "旭旭";

   public Students4(){
        System.out.println("子类的构造方法");
    }
    void test(String name){

        System.out.println(name);//student
        System.out.println(this.name);//student
        System.out.println(super.name);//person
    }



    void test1(){
        say();
        this.say();
        super.say();

    }



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

方法重写

方法重写只和非静态有关

重写不能重写private的方法
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但不能缩小
抛出异常：范围可以缩小，但不能扩大

子类重写方法必须和父类一样，但方法体不同

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

静态方法：方法的调用只和左边的数据类型有关、

非静态方法：方法调用和右边的数据类型有关

静态方法

package OOP;

import com.sun.media.sound.SoftTuning;

public class OverrideTest {
    public static void main(String[] args) {
        Person1 person1 = new Student5();
        Student5 student5 = new Student5();
        person1.say();//person say
        student5.say();//student say
    }
}
class Person1{

    static void say(){
        System.out.println("person say");
    }
}
//重写是方法重写，和属性无关
class Student5 extends Person1{
    static void say(){
        System.out.println("student say" );
    }
}

非静态方法

package OOP;

import com.sun.media.sound.SoftTuning;

public class OverrideTest {
    public static void main(String[] args) {
        Person1 person1 = new Student5();
        Student5 student5 = new Student5();
        person1.say();//student say
        student5.say();// student say
    }
}
class Person1{

    void say(){
        System.out.println("person say");
    }
}
//重写是方法重写，和属性无关
class Student5 extends Person1{
    @Override
    void say() {
        System.out.println("student say");
    }
}

多态性

多态注意事项

多态是方法的多态，属性没有多态
父类和子类有联系
存在条件，继承关系，方法需要重写，父类指向子类对象

package OOP;

public class PolymorphicTest
{
    public static void main(String[] args) {
    Person2 p1 = new Student6();
    Student6 s1 = new Student6();
    Object o1 = new Student6();
      p1.say();//方法重写前是person say 方法重写后是student say
      s1.say();//student say
        ((Student6) p1).eat();//父类没有的情况下 需强转才能调用子类方法
        s1.eat();
    }
}
class Person2{
    void say(){
        System.out.println("person say");
    }
}
class Student6 extends Person2{
    @Override
    void say() {
        System.out.println("student say");
    }
    void eat(){
        System.out.println("student eat");
    }
}

Instance of

子类转换为父类可能丢失一些自身的方法

父类转为子类得需要强制转换

package OOP;

public class InstanceOfTest
{
    public static void main(String[] args) {
        //instance 表示能不能编译通过
        Object o1 = new Student7();
        System.out.println(o1 instanceof Person3);//true
        System.out.println(o1 instanceof Student7);//true
        System.out.println(o1 instanceof Object);//true
        System.out.println(o1 instanceof teacher);//false
        System.out.println(o1 instanceof String);//false

        System.out.println("===============");
        Person3 p1 = new Student7();
        System.out.println(p1 instanceof Person3);//true
        System.out.println(p1 instanceof Student7);//true
        System.out.println(p1 instanceof Object);//true
        System.out.println(p1 instanceof teacher);//false
//        System.out.println(p1 instanceof String);//false 编译报错
        System.out.println("=================");
        Student7 s1 = new Student7();
        System.out.println(s1 instanceof Person3);//true
        System.out.println(s1 instanceof Student7);//true
        System.out.println(s1 instanceof Object);//true
//        System.out.println(s1 instanceof teacher);//false 编译报错
//        System.out.println(s1 instanceof String);//false 编译报错
    }
}
class Person3{}
class Student7 extends Person3 {}
class teacher extends Person3{};

static

非静态可以调用静态方法

调用非静态方法必须实例化

package OOP;

public class StaticTest {
    private static int age;//静态变量
    private double score;//非静态变量
    public static void main(String[] args) {
        StaticTest s = new StaticTest();
        System.out.println(StaticTest.age);
        System.out.println(s.age);
        System.out.println(s.score);
        //调用run
        new StaticTest().run();
        //调用go
        go();
    }
    void run(){
        go();
    }
    static void go(){}
}

静态代码块

静态代码块第一个执行且只能执行一次

匿名代码块每次都会执行，常用来添加变量

package OOP;

public class StaticCode {
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    StaticCode(){
        System.out.println("无参构造器");
    }

    public static void main(String[] args) {
        StaticCode staticCode = new StaticCode();
        System.out.println("==============");
        StaticCode staticCode1 = new  StaticCode();

    }
}

静态导包

package OOP;
import  static java.lang.Math.random;
import  static java.lang.Math.PI;
public class StaticPacketCode {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

final

final修饰的类不能被继承

抽象类

abstract：抽象类里面写有抽象方法抽象方法只有方法名字，没有方法体

继承抽象类的类必须要进行方法重写，若抽象类中有不抽象方法，此方法可以不用进行方法重写

package OOP;
//抽象类需要继承使用 extends 只能单继承 接口可以多继承
public abstract class AbstractClass {
    //abstract,抽象方法，只有方法名字，没有方法实现
  abstract void run();
  
}
class test1 extends AbstractClass{
    @Override
    void run() {

    }
}

不能new这个抽象类，只能靠子类去实现他，约束！
抽象类中可以写普通方法
抽象方法必须在抽象类中

接口

package OOP;

public interface InterfaceTest {
    //接口默认都是public abstract
    void add(String name);
    void delete(String name);
    void modify(String name);
    void query(String name);
}


//类可以实现接口 implement 接口
//类实现接口 需要重写接口中的方法
//利用接口可以实现多继承
class operate implements InterfaceTest,Server{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void modify(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void run() {

    }
}

interface Server{
    void run();
}

接口的作用：

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

内部类

成员内部类

package OOP.InnerClass;

public class member {
    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.new Inner();
        inner.in();
    }
   }
class Out{
    private    int id = 10;
    void Out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        //获得外部类的私有属性
        //若要静态获取外部类的私有属性 则外部类私有属性 内部类 以及 方法都必须加上static
        public  void getId(){
            System.out.println(id);
        }
        void  in(){
            System.out.println("这是内部类方法");
        }
    }

}

局部内部类

package OOP.InnerClass;

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

    }
    //局部内部类
    public void method(){
        class Inner{}
    }
}
//一个java文件中可以有多个class 但只能有一个public class

匿名内部类

package OOP.InnerClass;

public class Anonymity {
    public static void main(String[] args) {
        //没有名字初始化
        new test().run();
        new method() {
            @Override
            public void eat() {
                
            }
        };
    }
}
class test{
    void run(){}
}

interface method{
    void eat();
}