学习笔记之Java篇（0726）

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  运行时类型DogSystem.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("--向下转型-- 强制");
//    编译不会报错。运行会报异常：CLassCastExceptionif(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 {/*** 休息*/@Overridepublic void rest() {System.out.println("Dog.rest");}/*** 奔跑*/@Overridepublic void run() {System.out.println("Dog.run");}/*** 喊叫*/public void shout(){System.out.println("Dog.shout");}
}
class Cat extends Animal {@Overridepublic void rest(){System.out.println("Cat.rest");}@Overridepublic void run(){System.out.println("Cat,run");}@Overridepublic 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 {@Overridepublic void helpOther(){System.out.println("扶老奶奶过马路！");}
}
//鸟人 -- 飞翔
class BirdMan implements Volant{/*** 飞翔*/@Overridepublic void fly() {System.out.println("鸟人在飞！");}
}class Angel implements Volant,Honest {/***帮助别人*/@Overridepublic void helpOther() {System.out.println("天使乐于助人");}/***飞翔*/@Overridepublic void fly() {System.out.println("天使在飞翔");}
}class Plane implements Volant {@Overridepublic 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{@Overridepublic 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{@Overridepublic 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 {@Overridepublic void testC() {System.out.println("C");}@Overridepublic void testA() {System.out.println("A");}@Overridepublic 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） 不包括7System.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);}
}

请添加图片描述
字符串相等的判断

equals 方法用来检测两个字符串内容是否相等。如果字符串s 和t 内容相等，则s.equals(t)返回 true，否则返回 false。
要测试两个字符串除了大小写区别外是否是相等的，需要使用equalslgnoreCase方法。
判断字符串是否相等不要使用"=="

下班就开溜了

学习笔记之Java篇（0726）

2、封装

3、多态(polymorphism)

p 抽象类和接口

p 接口

p 字符串（String类）详解

最新新闻

热搜词