Bootstrap

java面向对象学习笔记

#

面向对象

一，设计对象并使用

类：是对对象共同特征的描述

对象：是真实存在的具体东西

image-20231123192732812

 public class PhoneTest {
     public static void main(String[] args){
         Phone p = new Phone();
         p.brand="小米";
         p.price=1999.98;
         System.out.println(p.brand);
         System.out.println(p.price);
         p.call();
         p.playGame();
     }
 }

 public class Phone {
     String brand;
     double price;
     public void call(){
         System.out.println("手机在打电话");
     }
 ​
     public void playGame(){
         System.out.println("手机在玩游戏");
     }
 }

image-20231123195121733

二，封装

1.什么是封装？

告诉我们，如何正确设计对象的属性和方法

原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

2.理解封装思想的好处？

让编程变得简单

降低我们学习的成本，可以少学少记

 public class GirlFriend {
      private double heighth;
      private int age;
      public void setHeighth(double n){
          if(n>=100&&n<=120){
              heighth=n;
          }
      }
      public double getHeighth(){
          return heighth;
      }
      public void setAge(int a){
          if(a>=18&&a<=20){
              age=a;
          }
      }
      public int getAge(){
          return age;
      }
 }

 public class GirlFriendtest {
     public static void main(String[] args){
         GirlFriend p= new GirlFriend();
         p.setHeighth(120.0);
         p.setAge(19);
         System.out.println(p.getHeighth());
         System.out.println(p.getAge());
     }
 }

image-20231123205815871

三，static 静态变量

 public class test1 {
     public static void main(String[] args){
         testKu.teacherName = "阿伟老师";
         testKu testku = new testKu();
         testku.setName("张三");
         testku.setAge(19);
         testku.study();
         testKu testku1 = new testKu();
         testku1.setName("李四");
         testku1.setAge(19);
         testku1.study();
     }
 }
 public class testKu {
     private String name;
     private int age;
     public static String teacherName;
     public testKu(){
 ​
     }
     public testKu(String name,int age){
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
     public void study(){
         System.out.println(name+age+teacherName);
     }
 }

image-20231128094431432

被静态变量修饰的变量是共享的

static 静态方法使用：

 public class test2 {
     public static void main(String[] args){
         int[] arr = {1,2,3};
         String newArr = wareHouse.reCreate(arr);
         System.out.println(newArr);
     }
 }

 public class wareHouse {
     private wareHouse(){
     }
     public static String reCreate(int[] arr){
         StringBuilder sb = new StringBuilder();
         sb.append("[");
         for (int i = 0; i < arr.length; i++) {
             if(i ==arr.length - 1){
                 sb.append(arr[i]);
             }else {
                 sb.append(arr[i]).append(",");
             }
         }
         sb.append("]");
         return sb.toString();
     }
 }

image-20231128113322072

static 工具类：

 public class Main {
     public static void main(String[] args){
         ArrayList<wareHouse> list = new ArrayList<>();
         wareHouse wareHouse1 = new wareHouse("李宇航",178.0,20);
         wareHouse wareHouse2 = new wareHouse("王铭杰",177.0,20);
         wareHouse wareHouse3 = new wareHouse("张梓豪",179.0,20);
         list.add(wareHouse1);
         list.add(wareHouse2);
         list.add(wareHouse3);
         int age = way.getName(list);
         System.out.println(age);
 ​
     }
 }

 public class wareHouse {
     private String name;
     private double high;
     private int age;
 ​
     public wareHouse(){}
 ​
     public wareHouse(String name , double high , int age){
         this.name = name;
         this.high = high;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public double getHigh() {
         return high;
     }
 ​
     public void setHigh(double high) {
         this.high = high;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 }

 
public class way {
     private way(){}
     public static int getName(ArrayList<wareHouse> list){
         int max = list.get(0).getAge();
         for (int i = 0; i < list.size(); i++) {
              int age = list.get(i).getAge();
             if(age > max){
                 max = list.get(i).getAge();
             }
         }
         return max;
     }
 }

static 注意事项：

image-20231128170034985

image-20231128170100139

四，继承

1.继承的用法定义：

java 中提供的一个关键字extends，用这个关键字可以让一个类与另一个类建立起继承关系。

Student 称为子类，Person 称为父类

继承就能把重复的代码实现公用

类与类之间，存在相同的内容，并满足子类是父类的一种，就可以考虑继承使用，来优化代码

注意：不能光看到相同的内容就抽取

继承的格式：

 public class 子类 extends 父类{}

子类可以得到父类的特征

并且可以在子类中添加新的功能

2.继承的特点：

  • java只支持单继承，不支持多继承，

  • 但支持多层继承：A可以继承B，B可以继承C，

    C叫A的间接父类

  • Java中的所有类都直接或间接继承于Object类

记着使用public关键字

image-20231128185405658

image-20231128185447382

3.子类可以继承的内容：

  • 构造方法：

非私有 不能 private 不能

  • 成员变量：

非私有 能 private 能

  • 成员方法：

  1. 虚方法表 ：

非private类

非static类

非final类1

4.成员变量的访问特点：

就近原则，离谁近就继承谁

 public class test5 {
     public static void main(String[] args){
         Zi z = new Zi();
         z.ziShow();
     }
 }
 class Ye{
     String name = "Ye";
 }
 class Fu extends Ye{
     String name = "Fu";
 }
 class Zi extends Fu{
     String name = "Zi";
     public void ziShow(){
         System.out.println(name);
         System.out.println(this.name);
         System.out.println(super.name);
     }
 }

image-20231128220406350

5.成员方法的访问特点：

this就近原则

super找父类里面的方法

方法重写：

当父类的方法不能满足子类的需求时，子类中的方法需要重写

方法重写的本质：

子方法的方法与父方法的方法发生重叠

子方法会覆盖父方法

image-20231128230846777

C类本来有1，2类

B将C的2覆盖

A将方法2覆盖

image-20231129161616158

image-20231129161645804

image-20231129161838027

6.构造方法的访问特点：

image-20231129163408612

五，多态

1.认识多态

多态可以用来对多个对象进行相同操作

比如说：注册教务系统

有老师注册和学生注册两种

image-20231129190701756

image-20231129192934001

image-20231129192953538

子类父类都要写方法，构造方法在父类里存储

测试方法里面有一个方法来接收父方法

在一个页面的用class 加类名就可以了

在多个页面里面就要加public了

2.多态调用成员的特点：

  • 调用成员变量

编译看左边，运行也看左边

  • 调用成员方法

编译看左边，调用看右边

 public class test9 {
     public static void main(String[] args){
         Animal a = new dog();
         System.out.println(a.name);
         a.animal();
     }
 }
 ​
 ​
 class Animal {
     String name = "动物";
     public void animal(){
         System.out.println("动物");
     }
 }
 class dog extends Animal{
     String name = "dog";
     public  void animal(){
         System.out.println("dog");
     }
 }

image-20231129195326277

在继承的时候子类会把父类的变量和方法都继承下来，但是变量没有被覆盖，而方法被子类覆盖

3.多态的优势和弊端：

image-20231129203921258

 public class test10 {
     public static void main(String[] args){
         person p = new person("李宇航",20);
         dog d = new dog(2,"黑");
         cat c = new cat(3,"灰");
         p.keepPet(d,"骨头");
         p.keepPet(c,"小鱼干");
     }
 }
 public class animal {
     private int age;
     private String color;
     public animal(){
     }
     public animal(int age,String color){
         this.age = age;
         this.color = color;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     public String getColor() {
         return color;
     }
 ​
     public void setColor(String color) {
         this.color = color;
     }
     public void eat(String something){
         System.out.println("动物在吃"+something);
     }
 }


 public class person {
     private String name;
     private int age;
     public person(){}
     public person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
     public void keepPet(animal a,String something){
         if(a instanceof dog d){
             System.out.println("年龄为"+age+"岁的"+name+"养了一只"+a.getColor()+"颜色的动物");
             d.eat(something);
         }else if(a instanceof cat c){
             System.out.println("年龄为"+age+"岁的"+name+"养了一只"+a.getColor()+"颜色的动物");
             c.eat(something);
         }
 ​
     }
 ​
 ​
 }

  • 在封装页面形参的位置放数组也可以被传入

  • 在test类里面使用时括号里有数组名就可以了

 public class dog extends animal{
     public dog(){
 ​
     }
     public dog(int age,String color){
         super(age, color);
     }
     public void eat(String something){
         System.out.println(getAge()+"岁的"+getColor()+"狗"+"正在吃"+something);
     }
     public void lookHome(){
         System.out.println("看家");
     }
 }


 public class cat extends animal{
     public cat() {
     }
 ​
     public cat(int age, String color) {
         super(age, color);
     }
     public void eat(String something){
         System.out.println(getAge()+"岁的"+getColor()+"猫"+"正在吃"+something);
     }
     public void catchMouse(){
         System.out.println("猫正在抓老鼠");
     }
 }

4.导包：

image-20231130205651754

导包时一定要找public类，没有public的类的无法使用

5.final：

image-20231130211645057

image-20231130211708723

final修饰常量比较常见，使用也较多

image-20231130211731606

常量只能被赋值一次

也必须要赋值

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性

常量的命名规范：

  • 单个单词：全部大写

  • 多个单词：全部大写，单词之间用下划线隔开

细节：

final修饰基本数据类型时，变量储存的值不能发生改变

final修饰引用类型时，变量储存的地址值不能发生改变

image-20231130215243497

直接改变内容时，是可以改变的

但是重新创建对象时，就会改变内容

image-20231130222538730

输出结果为ARR[0]=10;

ARR[1]=20;

数组也是引用数据类型可以改变其中的内容但是不会改变他的地址值

image-20231130223616304

image-20231130223555604

六，权限修饰符

image-20231130224015862

private 只能在自己的类里面使用

空只能在自己的包里面使用

protested 不同包里面可以使用比如说子类里面就可以使用，但是没关系不可以使用

public 公开使用

image-20231130225725498

七，代码块：

1.局部代码块：

image-20231130225928215

没啥卵用

2.构造代码块：

image-20231130230704955

鸡肋

3.静态代码块：

image-20231130230827606

image-20231130231509220

数据初始化

信息系统可能会用到

八，抽象类：

抽象类中不一定有抽象方法

抽象方法一定在抽象类下面

抽象类无法创建对象

抽象类的构造方法是用来给子类的共有属性进行赋值的

子类一定要继承父类的所有方法，否则就要报错

抽象类就是一种在父类里强制规定方法名字属性的方法，用来保证集体开发中的一种协作和专一

比如说在方法是否有返回值还有命名上来说，就能达到一致

 public class test11 {
     public static void main(String[] args){
         dog d = new dog();
         d.drink();
         d.eat();
         cat c = new cat();
         c.drink();
         c.eat();
     }
 }


 public abstract class animal {
     private String name;
     private int age;
     public animal(){}
     public animal(String name,int age){
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
     public abstract void eat();
     public abstract void drink();
 ​
 ​
 ​
 }


 public class dog extends animal{
     @Override
     public void eat() {
         System.out.println("狗吃骨头");
     }
 ​
     @Override
     public void drink() {
         System.out.println("狗喝水");
     }
 }


 public class cat extends animal{
     @Override
     public void eat() {
         System.out.println("猫吃鱼");
     }
 ​
     @Override
     public void drink() {
         System.out.println("猫喝水");
     }
 }

image-20231201103625483

九，接口：

不是每一个子类都使用父类里面的方法，所以创建一个接口来让子类来接收一些特有的方法

 public class dog extends animal implements swim{
     public dog() {
     }
 ​
     public dog(String name, int age) {
         super(name, age);
     }
 ​
     @Override
     public void eat() {
         System.out.println("狗吃骨头");
     }
 ​
     @Override
     public void drink() {
         System.out.println("狗喝水");
     }
     public void swimming(){
         System.out.println("青蛙在蛙泳");
     }
 }
 public interface swim {
     public abstract void swimming();
 ​
 ​
 }

image-20231201112019635

被禁用了，没什么卵用

接口里面有重复的方法名时

只要重写一次就了

image-20231201112756995

这样两个接口里面的方法都可以实现了，但是要是只实现第一个接口里面的该怎么做？

image-20231201115014698

image-20231201115133264

当子类接口被实现时，应该将父类里面的方法都写上

 public class test12 {
     public static void main(String[] args){
         PingPangSporter pps = new PingPangSporter("维克好",19);
         pps.study();
         pps.studyEnglish();
     }
 }






 public class Person {
     private String name;
     private int age;
     public Person(){
 ​
     }
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 }


 public abstract class sporter extends Person{
     public sporter() {
     }
 ​
     public sporter(String name, int age) {
         super(name, age);
     }
     public abstract void study();
 }


 public class PingPangSporter extends sporter implements English{
 ​
     public PingPangSporter() {
     }
 ​
     public PingPangSporter(String name, int age) {
         super(name, age);
     }
 ​
     @Override
     public void studyEnglish() {
         System.out.println("学英语");
     }
 ​
     @Override
     public void study() {
         System.out.println("学乒乓球");
     }
 }


 public interface English {
     public abstract void studyEnglish();
 }

十，JDK8新增方法：

1.默认方法：

在接口中书写要加default但是在实现时可以不用必须写

并且在测试类中可以直接调用

在实现时，重写方法不加default

image-20231201135452725

image-20231201135842198

静态的 ，私有的 ，final类的方法无法添加到虚方法表里面的

所以接口里面的静态方法无法继承，但可以在测试类里面实现调用

在接口里面有些语句是重复的，将他们抽取出来放在一个方法中，并且只让接口里面的方法使用时，就要用到private类，或者静态类

image-20231201140648586

image-20231201140940261

差别就是default类的默认方法，那么使用第一种

静态类的就要使用第二种

 
public interface freedom {
     public default void eat(){
         System.out.println("吃东西");
         kong();
     }
     public default void drink(){
         System.out.println("喝水");
         kong();
     }
     private void kong(){
         System.out.println("懒猪");
     }
     public static void eat1(){
         System.out.println("赤豆电脑关系");
         kong1();
     }
     public static void drink1(){
         System.out.println("喝东西");
         kong1();
     }
     private static void kong1(){
         System.out.println("没事干");
     }
 }

2.接口的实例：

image-20231201142743458

3.适配器：

在接口中的方法在被实现时，要全部重写，所以在使用某些方法时，其他方法就比较多余

所以构建一个适配器来与接口对接，然后再用实现类继承适配器，就可以实现对其中方法的特定使用

 public class freedomAdoper implements freedom{
     @Override
     public void drink() {
         freedom.super.drink();
     }
 ​
     @Override
     public void eat() {
         freedom.super.eat();
     }
 }


 public class test extends freedomAdoper{
     @Override
     public void drink() {
         super.drink();
     }
 }

适配器一般添加为abstract类

因为对适配器创建对象没啥实际意义

十一，内部类

1.是大类里面的一种类，单独存在时没什么意义

image-20231201144945554

image-20231201145150951

 public class test1 {
     public static void main(String[] args){
         Car c = new Car();
         c.brand = "bin";
         c.age = 10;
         c.color = "绿";
         c.show();
     }
 }




 public class Car {
     String brand;
     String color;
     int age;
     public void show(){
         nei n = new nei();
         System.out.println(brand);
         System.out.println(color);
         System.out.println(age);
         System.out.println(n.neiBrand);
         System.out.println(n.neiAge);
     }
     class nei{
         String neiBrand;
         int neiAge;
     }
 }

2.内部类的分类：

成员内部类：

image-20231201152753260

 public class Outer{
     String name;
     private class Inner{
     }
     public Inner getInstance(){
         return new Inner();
     }
 }

image-20231201153149690

image-20231201153211851

image-20231201153835852

2.静态内部类：

image-20231201154641413

 
public class test2 {
     public static void main(String[] args){
         Outer.inter i = new Outer.inter();
         i.show();
         Outer.inter.show2();
     }
 }




 public class Outer {
     static class inter{
         public void show(){
             System.out.println("内部类");
         }
         public static void show2(){
             System.out.println("静态类");
         }
     }
 }

静态内部类方法可以直接使用，非静态内部类方法需要创建对象

3.局部内部类:

在方法内部定义类的方法

package com.itheima;

public class test {
    public static void main(String[] args){
        int a=10;
        int b=10;
        System.out.println(a+b);
    }
    public void show(){
        int a = 10;
        class Inner{
            String name;
            int age;
            public void method1(){
                System.out.println("局部内部类中的method1方法");
            }
            public void method2(){
                System.out.println("局部内部类中的method1方法");
            }
        }
    }
}

4.匿名内部类

image-20231201163759137

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
vmware桥接解决DHCP不能自动获取IP
ctfshow-WEB-web4
springboot项目集成大数据第三方dolphinscheduler调度器 执行/停止任务
MATLAB基础应用精讲-【数模应用】Kappa一致性检验
进程间通信之共享内存
基于python+vue+elementUI+django基于python的图书馆管理系统(前后端分离)#毕业设计
Linux常见命令 5 - sort 排序
部署服务-Linux中安装nacos-2.2.3
[终端安全]-8 隐私保护和隐私计算技术
解决java.lang.RuntimeException: java.io.IOException: invalid constant type: 18
;