JAVA基础03
文章目录
- JAVA基础03
- 继承extends
-
- instanceof运算符
- 方法重写override
- Object类
-
- toString方法
- equals方法和==
- super关键字
-
- 继承树追溯
- 封装
- final关键字
- 抽象方法和抽象类
-
- 抽象方法
- 抽象类
- 接口
-
- 定义和使用接口
- 接口的多继承
- 内部类
-
- 内部类的作用
- 内部类的分类
- String
-
- String类和常量池
- String类常用的方法
- 字符串相等的判断
JAVA基础03
继承extends
- 如果定义一个类时，没有调用extends,则他的父类是：java.lang.Object
- Java中类没有多继承，接口有多继承
- 子类继承父类，可以得到除了父类的构造方法外父类的全部属性和方法
- 子类不可以直接访问父类的私有的属性和方法
- 父类也称作超类、基类、派生类等
/**
* 使用extends实现继承
* @author Carpediem
* @version 1.0
*/
public class Test {
public static void main(String[] args) {
Student s=new Student("Carpediem",168,"CS");
s.rest();
s.study();
}
}
class Person{
String name;
int height;
public void rest(){
System.out.println("Rest for a while");
}
}
class Student extends Person{
String major;
public void study(){
System.out.println("In UESTC,Studying CS");
}
public Student(String name,int height,String major){
// 继承父类的属性
this.name=name;
this.height=height;
this.major=major;
}
}
output:
Rest for a while
In UESTC,Studying CS
instanceof运算符
- 二元运算符，左边是对象，右边是类
- 对象是类或子类创建的对象时，返回true,否则false
/**
* 使用instanceof运算符进行类型判断
* @author Carpediem
* @version 1.1
*/
public class Test {
public static void main(String[] args) {
Student s=new Student("Carpediem",168,"CS");
System.out.println(s instanceof Person);
System.out.println(s instanceof Student);
}
}
output:
true
true
方法重写override
- 子类通过重写父类的方法，可以用自身的行为替换父类的行为
- 方法名、形参列表相同
- 返回值类型和声明异常类型，子类小于等于父类
- 访问权限，子类大于等于父类
- 方法重写是实现多态的必要条件
/**
* 测试方法重写
* @author Carpediem
* @version 1.0
*/
public class TestOverride {
public static void main(String[] args) {
Vehicle v1=new Vehicle();
Vehicle v2=new Bentley();
Vehicle v3=new Plane();
v1.run();
v2.run();
v3.run();
v2.stop();
v3.stop();
}
}
class Vehicle{
public void run(){
System.out.println("Running....");
}
public void stop(){
System.out.println("Stop!");
}
}
class Bentley extends Vehicle{
public void run(){
// 重写父类方法
System.out.println("Running quickly");
}
}
class Plane extends Vehicle{
public void run(){
System.out.println("Flying in the sky!");
}
public void stop(){
System.out.println("Land and Stop flying");
}
}
output:
Running....
Running quickly
Flying in the sky!
Stop!
Land and Stop flying
Object类
- Object类是所有Java类的根基类，即所有的Java对象都拥有Object类的属性和方法
public class Person {
...
}
//equal to ：
public class Person extends Object {
...
}
toString方法
- Object类中定义有public String toString()方法，其返回值是 String 类型。
源码为:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
/**
* 测试toString()方法重写
* @author Carpediem
* @version 2.0
*/
class Person{
String name;
int age;
@Override
public String toString(){
return name+",age:"+age;
}
}
public class TestOverride{
public static void main(String[] args) {
Person p=new Person();
p.age=22;
p.name="Lipton";
System.out.println("info:"+p);
TestOverride t=new TestOverride();
System.out.println(t);
}
}
output:
info:Lipton,age:22
TestOverride@1b6d3586
equals方法和==
- Object 的 equals 方法默认就是比较两个对象的hashcode(对象的内存地址)，是同一个对象的引用时返回 true 否则返回 false
- ==代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。
- JDK提供的一些类，如String、Date、包装类等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ，当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。
/**
* equals方法测试和自定义类重写equals方法
* @author Carpediem
* @version 1.0
*/
public class TestEquals {
public static void main(String[] args) {
Person p1 = new Person(123,"Carpediem");
Person p2 = new Person(123,"Prajna");
System.out.println(p1==p2); //false，不是同一个对象
System.out.println(p1.equals(p2)); //true，id相同则认为两个对象内容相同
String s1 = new String("Lipton");
String s2 = new String("Lipton");
System.out.println(s1==s2); //false, 两个字符串不是同一个对象
System.out.println(s1.equals(s2)); //true, 两个字符串内容相同
String s3 = new String("Lipton1");
System.out.println(s1==s3);//false
System.out.println(s1.equals(s3));//false
String s4=new String();
s4=s3;
System.out.println(s4==s3);//true
System.out.println(s3.equals(s4));//true
}
}
class Person {
int id;
String name;
public Person(int id,String name) {
this.id=id;
this.name=name;
}
public boolean equals(Object obj) {
if(obj == null){
return false;
}else {
if(obj instanceof Person) {
Person c = (Person)obj;
if(c.id==this.id) {
return true;
}
}
}
return false;
}
}
output:
false
true
false
true
false
false
true
true
super关键字
- super是直接父亲对象的引用
- 可以通过super来访问父类中被子类覆盖的方法或属性
- 使用super 调用普通方法，语句没有位置限制，可以在子类中随便调用
- 若是构造方法的第一行代码没有显式的调用super(…)或this(…)，Java将默认调用super()
继承树追溯
构造方法调用顺序：
构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。
注：静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。
public class TestSuper {
public static void main(String[] args) {
System.out.println("开始创建一个ChildClass对象......");
new ChildClass();
}
}
class FatherClass {
public FatherClass() {
System.out.println("创建FatherClass");
}
}
class ChildClass extends FatherClass {
public ChildClass() {
System.out.println("创建ChildClass");
}
}
output:
开始创建一个ChildClass对象......
创建FatherClass
创建ChildClass
封装
访问控制符：private、default、protected、public,说明了面向对象的封装性
- private 表示私有，只有自己类能访问
- default表示没有修饰符修饰，只有同一个包的类能访问
- protected表示可以被同一个包的类以及其他包中的子类访问
- public表示可以被该项目的所有包中的所有类访问
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
// this.age = age;//构造方法中不能直接赋值，应该调用setAge方法
setAge(age);
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
//在赋值之前先判断年龄是否合法
if (age > 130 || age < 0) {
this.age = 18;//不合法赋默认值18
} else {
this.age = age;//合法才能赋值给属性age
}
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
//p1.name = "hh"; //编译错误
//p1.age = -45; //编译错误
p1.setName("Carpediem");
p1.setAge(-45);
System.out.println(p1);
Person p2 = new Person("Lipton", 300);
System.out.println(p2);
}
}
output:
Person [name=Carpediem, age=18]
Person [name=Lipton, age=18]
final关键字
- 修饰变量：被修饰的变量一旦赋值，不能被重新赋值
- 修饰方法：该方法不可被子类重写，但可被重载
- 修饰类：修饰的类不能被继承
抽象方法和抽象类
抽象方法
- 使用abstract修饰的方法，没有方法体，只有声明
- 定义的是一种规范，就是规定子类必须要给抽象方法提供具体的实现
- 抽象方法必须被子类实现。
抽象类
- 包含抽象方法的类就是抽象类，即有抽象方法的类只能定义成抽象类
- 通过abstract方法定义规范，然后要求子类必须定义具体实现
- 通过抽象类，就可以严格限制子类的设计，使子类之间更加通用
- 抽象类不能实例化，即不能用new来实例化抽象类。
- 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
- 抽象类只能用来被继承。
接口
- 接口就是规范，是比抽象类还抽象的抽象类，更加规范的对子类的约束
- 接口全面专业地实现了规范和具体实现的分离
抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
从接口的实现者角度看，接口定义了可以向外部提供的服务。
从接口的调用者角度看，接口定义了实现者能提供那些服务。
接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。
接口和实现类不是父子关系，是实现规则的关系。比如：我定义一个接口Runnable，Car实现它就能在地上跑，Train实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现Runnable接口。
定义和使用接口
[访问修饰符] interface 接口名 [extends 父接口1，父接口2...]{
常量定义；
方法定义；
}
- 访问修饰符：只能是public或默认
- extends：接口可以多继承
- 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
- 方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。
/**
* 接口的使用
* @author Carpediem
* @version 1.0
*/
public class Test
{
public static void main(String[] args) {
Angel a1=new Angel();
a1.fly();
a1.helpOther();
System.out.println(Volant.FLY_HIGHT);
GoodMan g1=new GoodMan();
g1.helpOther();
}
}
interface Volant{
int FLY_HIGHT=100;//总是：public static final 类型的
void fly();//总是：public abstract void fly()
}
interface Kindness{
void helpOther();
}
class Angel implements Volant,Kindness{
@Override
public void fly() {
System.out.println("I am Angel,I am flying");
}
@Override
public void helpOther() {
System.out.println("I am helping others,I am Angel");
}
}
class GoodMan implements Kindness{
@Override
public void helpOther() {
System.out.println("I am GoodMan ,I am helping others.");
}
}
output：
I am Angel,I am flying
I am helping others,I am Angel
100
I am GoodMan ,I am helping others.
- 子类通过implements来实现接口中的规范。
- 接口不能创建实例，但是可用于声明引用变量类型。
- 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的
接口的多继承
- 接口完全支持多继承
- 子接口扩展某个父接口，将会获得父接口中所定义的一切。
/**
* 接口的多继承
* @author Carpediem
* @version 1.0
*/
interface A{
void testa();
}
interface B{
void testb();
}
interface C extends A,B{
void testc();
}
public class Test implements C
{
public static void main(String[] args) {
Test t=new Test();
t.testa();
t.testb();
t.testc();
}
@Override
public void testa() {
System.out.println("Test1");
}
@Override
public void testb() {
System.out.println("Test2");
}
@Override
public void testc() {
System.out.println("Test3");
}
}
output:
Test1
Test2
Test3
内部类
- 把一个类放在另一个类的内部定义，称为内部类
- 内部类只是编译时的一个概念，一旦编译成功，就会称为完全不同的两个类，因此，内部类是相对独立的一种存在，其成员变量/方法名可以和外部类的相同。
- 内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。
内部类的作用
- 只能让外部类直接访问，不允许同一个包中其他类的直接访问
- 内部类可以直接访问外部类的属性，外部类不能访问内部类的内部属性
- 接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整
内部类的使用场合：
- 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，在只为外部类提供服务的情况下可以优先考虑使用内部类。
- 使用内部类间接实现多继承：每个内部类都能独立地继承一个类或者实现某些接口，所以无论外部类是否已经继承了某个类或者实现了某些接口，对于内部类没有任何影响。
内部类的分类
成员内部类（非静态内部类、静态内部类）、匿名内部类、局部内部类
1. 非静态内部类
-
非静态内部类必须寄存在一个外部类对象里，非静态内部类对象单独属于外部类的某个对象
-
非静态内部类中不能有static
-
非静态内部类可以直接访问外部类的成员，但外部类不能直接访问非静态内部类的成员（需要通过外部类对象来创建内部类对象，从而实现访问）
-
外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例
-
成员变量的访问、内部类的访问
public class Test{ private int age=10; class Inner{ int age=20; public void show(){ int age=30; System.out.println("内部类方法里的局部变量"+age); System.out.println("内部类的成员变量"+age); System.out.println("外部类的成员变量"+Test.this.age); } } public static void main(String[] args) { Test.Inner i1=new Test().new Inner(); i1.show(); Test t1=new Test(); Test.Inner it1=t1.new Inner(); it1.show(); } } Output: 内部类方法里的局部变量30 内部类的成员变量30 外部类的成员变量10 内部类方法里的局部变量30 内部类的成员变量30 外部类的成员变量10
2. 静态内部类
public class Test{
private int age=10;
static class Inner{
int age=20;
public void show(){
int age=30;
System.out.println("内部类方法里的局部变量"+age);
System.out.println("内部类的成员变量"+age);
// System.out.println("外部类的成员变量"+Test.this.age);//Error:(9, 47) java: 无法从静态上下文中引用非静态 变量 this
}
}
public static void main(String[] args) {
// Test.Inner i1=new Test().new Inner();
Test.Inner i1=new Test.Inner();
i1.show();
Test t1=new Test();
// Test.Inner it1=t1.new Inner();//Error:(19, 24) java: 限定的新静态类
}
}
Output:
内部类方法里的局部变量30
内部类的成员变量30
3. 匿名内部类
- 适合那种只需要使用一次的类。比如：键盘监听操作
- 匿名内部类没有访问修饰符
- 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。
???
4. 局部内部类
内部类，它是定义在方法内部的，作用域只限于本方法，称为局部内部类
String
-
String类又称作不可变字符序列
-
String 位于java.lang包中，Java程序默认导入java.lang包下的所有类
-
Java字符串就是Unicode字符序列
-
Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。
-
字符串连接+把两个字符串按给定的顺序连接在一起，并且是完全按照给定的形式
-
"+"运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。
public class Test{ public static void main(String[] args) { String s1="Hello"; String s2="World"; System.out.println(s1+s2); int age=18; String str = "age is" + age; //str赋值为"age is 18" //这种特性通常被用在输出语句中： System.out.println("age is " + age); System.out.println(str); } } Output： HelloWorld age is 18 age is18
String类和常量池
在Java的内存分析中，我们会经常听到关于“常量池”的描述，实际上常量池也分了以下三种：
1. 全局字符串常量池(String Pool)
全局字符串常量池中存放的内容是在类加载完成后存到String Pool中的，在每个VM中只有一份，存放的是字符串常量的引用值(在堆中生成字符串对象实例)。
2. class文件常量池(Class Constant Pool)
class常量池是在编译的时候每个class都有的，在编译阶段，存放的是常量(文本字符串、final常量等)和符号引用。
3. 运行时常量池(Runtime Constant Pool)
运行时常量池是在类加载完成之后，将每个class常量池中的符号引用值转存到运行时常量池中，也就是说，每个class都有一个运行时常量池，类在解析之后，将符号引用替换成直接引用，与全局常量池中的引用值保持一致。
【示例5-28】常量池
String str1 = "abc"; String str2 = new String("def"); String str3 = "abc"; String str4 = str2.intern(); String str5 = "def"; System.out.println(str1 == str3);// true System.out.println(str2 == str4);// false System.out.println(str4 == str5);// true示例5-28的首先经过编译之后，在该类的class常量池中存放一些符号引用，然后类加载之后，将class常量池中存放的符号引用转存到运行时常量池中，然后经过验证，准备阶段之后，在堆中生成驻留字符串的实例对象(也就是上例中str1所指向的“abc”实例对象)，然后将这个对象的引用存到全局String Pool中，也就是String Pool中，最后在解析阶段，要把运行时常量池中的符号引用替换成直接引用，那么就直接查询String Pool，保证String Pool里的引用值与运行时常量池中的引用值一致，大概整个过程就是这样了。
回到示例5-28的那个程序，现在就很容易解释整个程序的内存分配过程了，首先，在堆中会有一个“abc”实例，全局String Pool中存放着“abc”的一个引用值，然后在运行第二句的时候会生成两个实例，一个是“def”的实例对象，并且String Pool中存储一个“def”的引用值，还有一个是new出来的一个“def”的实例对象，与上面那个是不同的实例，当在解析str3的时候查找String Pool，里面有“abc”的全局驻留字符串引用，所以str3的引用地址与之前的那个已存在的相同，str4是在运行的时候调用intern()函数，返回String Pool中“def”的引用值，如果没有就将str2的引用值添加进去，在这里，String Pool中已经有了“def”的引用值了，所以返回上面在new str2的时候添加到String Pool中的 “def”引用值，最后str5在解析的时候就也是指向存在于String Pool中的“def”的引用值，那么这样一分析之后，结果就容易理解了。
String类常用的方法
public class Test{
public static void main(String[] args) {
String s1="Hello";
String s2="World";
String s3="hello";
System.out.println(s1.charAt(3));//l
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s3));//true
System.out.println(s1.equals(s3));//false
System.out.println(s1.indexOf("ll"));//2
}
}
字符串相等的判断
-
equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等，则s.equals(t)返回true，否则返回false。
-
要测试两个字符串除了大小写区别外是否是相等的，需要使用equalsIgnoreCase方法。
-
判断字符串是否相等不要使用"=="。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9YatKb1q-1659155358504)(C:\Users\Carpediem\AppData\Roaming\Typora\typora-user-images\image-20220730121519202.png)]
public class Test{
public static void main(String[] args) {
String g1 = "HelloWorld";
String g2 = "HelloWorld";
String g3 = new String("HelloWorld");
System.out.println(g1 == g2); // true 指向同样的字符串常量对象
System.out.println(g1 == g3); // false g3是新创建的对象
System.out.println(g1.equals(g3)); // true g1和g3里面的字符串内容一样
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwDMgd4j-1659155358505)(C:\Users\Carpediem\AppData\Roaming\Typora\typora-user-images\image-20220730122030611.png)]