学习笔记之Java篇（0726）

尸僵打怪兽

于 2024-07-26 17:55:50 发布

阅读量496

点赞数 4

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/m0_70630166/article/details/140721577

版权

2、封装

1、封装的使用细节

请添加图片描述

2、开发中封装的简单规则：

属性一般使用private访问权限。
- 属性私有后，提供相应的get/set方法来访问相关属性，这些方法通常是public修饰后，以提供属性的赋值与读取操作（注意：boolean变量的get方法是is开头）
方法：一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

package Object.Wrap;

//JavaBean
public class User {
  private int id;
  private String name;
  private boolean man;

  public int getId() {
    return id;
  }

  public String getName() {
    return name;
  }

  public boolean isMan() {
    return man;
  }

  public void setId(int id) {
    this.id = id;
  }

  public void setName(String name) {
    this.name = name;
  }

  public void setMan(boolean man) {
    this.man = man;
  }


  public void printUserInfo(){
    System.out.println(id);
    System.out.println(name);
    System.out.println(man);
  }
}


package Object.Wrap;

public class Test {
  public static void main(String[] args) {
    User u = new User();
    u.setId(100);
    u.setName("msyy");
    u.setMan(true);
    System.out.println(u.getName());
    System.out.println(u.isMan());
  }
}

3、多态(polymorphism)

请添加图片描述
多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。
多态的存在要有3个必要条件：继承、方法重写、父类引用指向子类对象。
父类引用指向子类对象后，用该父类调用子类重写的方法，此时多态就出现了。

package Object.Wrap;

public class Animal {
   public void shout(){
     System.out.println("叫了一声！");
   }
}

class Dog extends Animal{
  public void shout(){
    System.out.println("汪汪汪...");
  }
  public void seeDoor(){
    System.out.println("看门中...");
  }
}
class Cat extends Animal{
  public void shout(){
    System.out.println("喵喵喵...");
  }
}


//测试
package Object.Wrap;

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

  animalCry(new Cat());
  animalCry(new Dog());
  animalCry(new Animal());

    System.out.println("----------------------------测试--------------------");
  Animal d = new Dog();
  d.shout();
//  无法调用Dog的独有方法，因为编译器只认Animal d 为Animal的对象
//  d.seeDoor();

  Animal c = new Cat();
  c.shout();



  }
  static void animalCry(Animal a){
    a.shout(); //可以出现多态
  }
}

对象的转型（casting）

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

 Animal c = new Cat();
  c.shout();

向上转型后的父类引用变量只能调用它变异类型的方法，不能调用它运行时类型的方法，这时我们就需要进行类型的强制转换，我们称之为向下转型。

Cat c2 = (Cat) c;
      c2.catchMouse();

源码

package Object.Wrap;

public class Animal {
   public void shout(){
     System.out.println("叫了一声！");
   }
}

class Dog extends Animal{
  public void shout(){
    System.out.println("汪汪汪...");
  }
  public void seeDoor(){
    System.out.println("看门中...");
  }
}
class Cat extends Animal{
  public void shout(){
    System.out.println("喵喵喵...");
  }

  public void catchMouse(){
    System.out.println("捉老鼠...");
  }
}




package Object.Wrap;

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

  animalCry(new Cat());
  animalCry(new Dog());
  animalCry(new Animal());

    System.out.println("----------------------------测试--------------------");
// 编译类型 Animal  运行时类型Dog
    System.out.println("--向上转型--自动");
  Animal d = new Dog();
  d.shout();
    System.out.println();
    System.out.println("--向下转型--强制");
    if(d instanceof Dog){
      Dog d2 = (Dog) d;
      d2.seeDoor();
    }

    System.out.println();
    System.out.println("--向上转型-- 自动");
  Animal c = new Cat();
  c.shout();
    System.out.println();
   System.out.println("--向下转型-- 强制");
//    编译不会报错。运行会报异常：CLassCastException
    if(c instanceof Cat){
      Cat c2 = (Cat) c;
      c2.catchMouse();
    }



  }
  static void animalCry(Animal a){
    a.shout(); //可以出现多态
  }
}

请添加图片描述

p 抽象类和接口

1、抽象方法和抽象类

抽象方法
1. 使用abstract修饰的方法，没有方法体，只有声明。
2. 定义的是一种规范，就是告诉子类必须要给抽象方法提供具体的实现。
抽象类
1. 包含抽象方法的类就是抽象类。
2. 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
抽象类的使用要点：
1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。

package Object.Abstact;

public abstract class Animal {
  int age;
  public abstract void rest();
  public abstract void run();

  public void shout(){
    System.out.println("Animal.shout");
  }
}
class Dog extends Animal {
  /**
   * 休息
   */
  @Override
  public void rest() {
    System.out.println("Dog.rest");
  }

  /**
   * 奔跑
   */
  @Override
  public void run() {
    System.out.println("Dog.run");
  }

  /**
   * 喊叫
   */
  public void shout(){
    System.out.println("Dog.shout");
  }
}
class Cat extends Animal {
  @Override
  public void rest(){
    System.out.println("Cat.rest");
  }
  @Override
  public void run(){
    System.out.println("Cat,run");
  }

  @Override
  public void shout() {
    System.out.println("Cat.shout");
  }
}

p 接口

接口就是一组规范（就像我们人间的法律一样），所有实现类都要遵守。请添加图片描述
1、接口的作用

为什么需要接口？接口和抽象类的区别？

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面、专业地实现了：规范和具体实现的分离。

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。工作以后，做系统时，往往就是使用“面向接口”的思想来设计系统。

接口和实现类不是父子关系，时实现规则的关系。。比如：我定义一个接口Runnable，Car 实现它就能在地上跑，Train 实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现 Runnable 接口。

2、如何定义和使用接口

声明格式：

[访问修饰符] +interface 接口名[extends父接口 1，父接口 2...]{
常量定义;
方法定义;
}

定义接口的详细说明：

访问修饰符：只能是public 或默认。
接口名：和类名采用相同命名机制。
extends:接口可以多继承
常量：接口中的属性只能是常量，总是：public static final 修饰，不写也是
方法：接口中的方法只能是：public abstract。省略的话，也是 public abstract。

要点：

子类通过implements来实现接口中的规范。
接口不能创建实例，但是可用于声明引用变量类型。
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
JDK1.8（不含8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
JDK1.8（含8）后，接口中包含普通的静态方法、默认方法。

package Object.TestInterface;

import InitStudy1.连接符;

//飞行接口
public interface Volant {
//  public static final  可省略
  public static final int FLY_HEIGHT = 100;
//   public abstract 可省略
  public abstract void fly();
}

//善良接口
interface Honest {
  void helpOther();
}

//好人 -- 善良
class GoodMan implements Honest {
  @Override
  public void helpOther(){
    System.out.println("扶老奶奶过马路！");
  }
}
//鸟人 -- 飞翔
class BirdMan implements Volant{
  /**
   * 飞翔
   */
  @Override
  public void fly() {
    System.out.println("鸟人在飞！");
  }
}

class Angel implements Volant,Honest {

  /**
   *帮助别人
   */
  @Override
  public void helpOther() {
    System.out.println("天使乐于助人");
  }

  /**
   *飞翔
   */
  @Override
  public void fly() {
    System.out.println("天使在飞翔");
  }
}

class Plane implements Volant {
  @Override
  public void fly(){
    System.out.println("飞机，在飞翔");
  }
}


//测试
package Object.TestInterface;

public class Test {
  public static void main(String[] args) {
    Angel a = new Angel();
    a.fly();
    a.helpOther();
    System.out.println(Volant.FLY_HEIGHT);


//    向上转换
    Volant v = new Angel();
    v.fly();
//    类型是Volant
//    v.helpOther();
  }
}

请添加图片描述
3、接口中定义静态方法和默认方法（JDK8)

JAVA8之前，接口的方法要求全部是抽象方法。

JAVA8（含8）之后，以后允许在接口里定义默认方法和静态方法。
请添加图片描述
3.1 默认方法

JAVA8及以上新版本，允许接口添加一个非抽象的方法实现，只需要使用default关键字即可，这个特征又叫做默认方法（也称扩展方法）。

默认方法和抽象方法的区别：抽象方法必须要被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这接口的实现类都可以得到默认方法。

package Object.TestInterface;

public interface TestDefault {
  void print();
  default void printMoren(){
    System.out.println("测试默认方法");
  }
}
class DedaultImpl implements TestDefault{
  @Override
  public void print(){
    System.out.println("实现（print）方法");
  }
}



   System.out.println("==================测试默认方法======================");
    TestDefault td = new DedaultImpl();
    td.printMoren();
    td.print();
  }

请添加图片描述
3.2 JDK8 新特性——静态方法

JAVA8以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。

如果子类中定义了相同字的静态方法，那就是完全不同的方法了，直接从属于子类可以通过子类名直接调用，就是咱们之前讲过的静态方法

package Object.TestInterface;

public interface TestDefault {
  void print();
  default void printMoren(){
    System.out.println("测试默认方法");
//    默认方法里可以调用静态方法，但是静态方法里只能调用静态方法，不能调用默认方法或者其他方法
    printStatic();
  }

//  静态方法
  static void printStatic(){
    System.out.println("接口里的静态方法");
  }
}
class DedaultImpl implements TestDefault{
  @Override
  public void print(){
    System.out.println("实现（print）方法");
  }
  static void printStatic(){
    System.out.println("子类里的静态方法");
  }
}




package Object.TestInterface;

public class Test {
  public static void main(String[] args) {
    Angel a = new Angel();
    a.fly();
    a.helpOther();
    System.out.println(Volant.FLY_HEIGHT);


//    向上转换
    Volant v = new Angel();
    v.fly();
//    类型是Volant
//    v.helpOther();

    System.out.println("==================测试默认方法======================");
    TestDefault td = new DedaultImpl();
    td.printMoren();
    td.print();
    System.out.println("==================测试静态方法======================");
//    静态方法要通过  类名.方法名（）调用
    TestDefault.printStatic();
    DedaultImpl.printStatic();
  }
}

由此可以知道：

默认方法里可以调用静态方法，但是静态方法里只能调用静态方法，不能调用默认方法或者其他方法。
实现类中的静态方法和接口里的静态方法是完全不同的方法（类似于重写）
调用静态方法：类名.静态方法名()

3.4 接口的多继承

接口支持多继承。和类的继承类似，子接口extends父接口，会获得父接口中的一切。
请添加图片描述

package Object.TestInterface;

public class TestMultipleInheritance {
  public static void main(String[] args) {
  implC c = new implC();
  c.testA();
  c.testB();
  c.testC();
  }
}

interface A {
  void testA();
}
interface B{
  void testB();
}
interface C extends A,B{
  void testC();
}
  class implC implements C {
    @Override
    public void testC() {
      System.out.println("C");
    }

    @Override
    public void testA() {
      System.out.println("A");
    }

    @Override
    public void testB() {
      System.out.println("B");
    }
  }

请添加图片描述

p 字符串（String类）详解

String 是最常用的类，要掌握String类常见的方法，它底层实现也需要掌握好，避免在工作开发中犯错。请添加图片描述
垂涎欲滴 >_< )

String:就是把一推字符串起来，统一使用。

String类又称为不可变字符序列
String位于*java.lang*包中，JAVA程序默认导入java.lang包下的所有类。
JAVA字符串就是Unicode字符序列。
JAVA没有内置的字符串类型，而在标准的JAVA类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。

package Object.String;

public class LokkString {
  public static void main(String[] args) {
    String s0 = null;
    String s1 = "";
    String s3 = "java";
    String s4 = new String("JavaScript");
    System.out.println(s1.length());
    System.out.println(s3.length());
    System.out.println(s4.length());
//    不能获取 s0 的长度，会报错 NullPointerException
//    System.out.println(s0.length());
    System.out.println(s1.isEmpty());
  }
}

请添加图片描述
String 类和常量池
每个class都有一个运行时常量池

Java内存分析中，我们会经常听到关于"常量池”的描述，实际上常量池也分了以下三种：全局字符串常量池、class 文件常量池、运行时常量池(Runtime ConstantPool)。我们只关注运行时常量池即可。

  System.out.println("=======================字符串的相关问题====================");
    String s5 = "java";
    String s6 = "java";
    String s7 = new String("java");

    System.out.println("s5等于s6吗 "+(s5 == s6));
    System.out.println("s5等于s7吗 "+(s5 == s7));
    System.out.println("equals比较s5和s7  "+s5.equals(s7));

请添加图片描述
String常用方法

方法	含义
char charAt(int index)	返回字符串中第index个字符
boolean equals(String other)	如果字符串与other相等，返回true;否则，返回false
boolean equalslgnoreCase（String other)	如果字符串与other 相等（忽略大小写），则返回 true；否则，返回false
int indexOf(String str)	返回从头开始查找第一个子字符串 str在字符串中的索引位置。如果未找到子字符串 str，则返回-1。
lastIndexOf()	返回从末尾开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串 str，则返回-1。
int length()	返回字符串的长度
String repalce(char oldChar,char newChar)	返回一个新串，它是通过用 newChar替换此字符串中出现的所有 oldChar而生成
boolean startsWith(String prefix)	如果字符串是以prefix开始，则返回true.
boolean endsWith(String prefix)	如果字符串以 prefix 结尾，则返回 true。
String substring(int beginlndex,int endlndex)	返回一个新字符串，该串包含从原始字符串beginlndex到串尾或endIndex - 1 的所有字符（左闭右开）
String toLowerCase()	返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母。
String toUpperCase()	返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母。
String trim()	返回一个新字符串，该串删除了原始字符串头部和尾部的空格。

package Object.String;

public class StringIndex01 {
  public static void main(String[] args) {
    String s1 = "core Java";
    String s2 = "Core Java";
    System.out.println(s1.charAt(3)); //取下标为3的字符
    System.out.println(s2.length());
    System.out.println(s1.equals(s2));//两个字符串是否相等(不会忽略大小写）
    System.out.println(s1.equalsIgnoreCase(s2));//两个字符串（忽略大小写）
    System.out.println(s1.indexOf("Java")); //字符串s1中是否包含 Java, 包含返回第一次出现的位置下标，不包含返回 -1

      //返回的是全新的字符串，不是原本的字符串了
    String  s = s1.replace(' ','&');//将s1中的空格替换为 &
    System.out.println("result is "+s);
      
    String s3 = "I love Java. Java is best language! Who love Java?";
    System.out.println(s3.indexOf("Java"));
    System.out.println(s3.lastIndexOf("Java"));
  }
}

请添加图片描述

package Object.String;

public class StringIndex02 {
  public static void main(String[] args) {
    System.out.println("++++++++++++=startWith & endsWith +++++++++++++");
    String s = "";
    String s1 = "How are you?";
    System.out.println(s1.startsWith("How")); //是否以How开头
    System.out.println(s1.endsWith("you")); //是否以How结尾

    System.out.println("=========================substring==========================");
    s = s1.substring(4); //子字符串：从下标为4的开始到字符串结尾为止
    System.out.println(s);
    s = s1.substring(4,7);//提取子字符串：下标 [4，7） 不包括7
    System.out.println(s);

    System.out.println("==========================toLowerCase========================");
    s = s1.toLowerCase(); //小写
    System.out.println(s);
    System.out.println("=========================toUpperCase==========================");
    s = s1.toUpperCase();
    System.out.println(s);

    System.out.println("==========================trim==========================");
    String s2 = "  How are you!! ";
    s = s2.trim();
    System.out.println("s:"+s);
    System.out.println("s2:"+s2);
  }
}