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、抽象方法和抽象类
-
抽象方法
- 使用
abstract修饰的方法，没有方法体，只有声明。 - 定义的是一种规范，就是告诉子类必须要给抽象方法提供具体的实现。
- 使用
-
抽象类
- 包含抽象方法的类就是抽象类。
- 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
-
抽象类的使用要点：
- 有抽象方法的类只能定义成抽象类
- 抽象类不能实例化，即不能用
new来实例化抽象类 - 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来
new实例，只能用来被子类调用。 - 抽象类只能用来被继承。
- 抽象方法必须被子类实现。
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方法。
- 判断字符串是否相等不要使用"=="
下班就开溜了
