java抽象类重载_012 JAVA 抽象类、接口、String类的基础了解

超、凢脫俗 2022-11-04 00:46 149阅读 0赞

1.抽象方法和抽象类

抽象方法：使用abstract修饰的方法，没有方法体，只有声明。抽象方法可以当做是一种规范，让子类必须实现。

注意：

1.抽象方法没有方法体，只能以分号结尾

2.抽象方法只能声明在抽象类中(含有抽象方法的类一定是抽象类)

3.抽象方法必须被子类实现；子类如果不能实现抽象方法，子类也必须是抽象类

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

包含抽象方法的类就是抽象类，通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用

注意：

1.有抽象方法的类只能定义成抽象类，但抽象类中不一定有抽象方法

2. 抽象类不能实例化，即不能用new来实例化抽象类。

3. 抽象类可以包含属性、方法、构造方法、final修饰的方法。但是构造方法不能用来new实例，只能用来被子类调用。

4.抽象类中可以包含0个或多个抽象方法

4.抽象类只能用来被继承。

5. 抽象方法必须被子类实现；子类如果不能实现抽象方法，子类也必须是抽象类

抽象类：

package com.sxt.abstract01;

/\*\*\* 使用abstract修饰的类称为抽象类\* @author 沐羽\* 时间：2019年7月22日上午9:20:32\*/

public abstract class Person \{

//1.成员变量、实例变量、属性private String name;

//2.成员方法、实例方法public void intro() \{

System.out.println("大家好，我的名字是："+name);

//3.静态方法public static void show() \{

//抽象类可以有 4.构造方法public Person() \{

System.out.println("Person类的无参构造方法");

//5.final修饰的方法，只能被子类调用，不能被子类重写public final void fun() \{

继承类及main方法：

package com.sxt.abstract01;

public class Student extends Person\{

public Student() \{

super();//调用父类中的无参构造方法

System.out.println("Student类中的无参构造方法");

public static void main(String\[\] args) \{

//Cannot instantiate the type Person抽象类不可以创建对象

//Person person = new Person();

Student stu = new Student();

public abstract class Animal \{

public abstract void shout();

class Dog extends Animal\{

@Override

public void shout() \{

System.out.println("汪汪汪.......");

class Cat extends Animal\{

@Override

public void shout() \{

System.out.println("喵喵喵.........");

public class Test \{

public static void main(String\[\] args) \{

Animal dog = new Dog();

Animal cat = new Cat();

dog.shout();

cat.shout();

2.接口

如果一个类中所有的方法均为 abstract 方法，那么这个类就可以声明为接口。接口不提供任何实现，接口是完全面向规范的，规定了一批类具有的公共方法规范。

\*从接口的实现者角度看，接口定义了可以向外部提供的服务。

\*从接口的调用者角度看，接口定义了实现者能提供那些服务。

接口的本质是契约，ike the law, we must obey by it!

2.1 接口的定义

使用interface修饰是一种数据类型，引用类数据型

public interface接口名 \{

//方法名

注意：

1.访问修饰符只能是public或默认

2.接口名和类名采用相同命名机制

3.接口可以多继承(implements 接口1,接口2...)

4.接口不能创建实例，但是可用于声明引用变量类型

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

2.2 接口中可以出现的----

a.抽象方法(public abstract 方法)

b.非抽象方法(JDK1.8新特性 ,必须使用default关键字)

public default void method() \{

c.属性(public static final修饰，可省略)常量

public interface MyInterface \{

//抽象方法

void show();

String fun();

int\[\] method();

//非抽象方法

public default void method01() \{

//属性常量(public static final修饰，可省略)

String name = "张飒";

public static final String name1 ="王五";

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

2.3 类与接口的关系

1.类去实现接口的抽象方法 implements(实现关系)

2.当一个类既有继承又有实现关系时，继承(extends)在前，实现(implements)在后

3.当父类中有与接口中完全一样的方法时，父类优先于接口

4.父类与接口中有同名方法时，在子类(实现类)中要构成方法的重载

接口类：

package com.sxt.interface02;

public interface Play \{

public void show();

public void show(String name);

父类：

package com.sxt.interface02;

public abstract class Person \{

public abstract void show();

子类(实现类)：

package com.sxt.interface02;

/\*\*

\* 先继承后实现 extends在前，implements灾后

\*/

public class Student extends Person implements Play\{

//父类与接口中有完全相同的方法，子类实现的是父类中的方法

@Override

public void show() \{

// TODO Auto-generated method stub

//父类与接口中的方法，在子类/实现类中构成方法的重载

@Override

public void show(String name) \{

// TODO Auto-generated method stub

接口的使用:

package com.sxt.interface03;

public class TestInterface \{

public static void main(String\[\] args) \{

Angel angel = new Angel();

angel.fly();

Volant volant = new BirdMan();

volant.fly();

Honest honest = new GoodMan();

honest.helpOther();

//飞行的接口

interface Volant\{

int SPEED = 100;//接口中的变量是使用public static final修饰的常量

//飞行的方法

void fly();

//善良的接口

interface Honest\{

//帮助他人

void helpOther();

//实现接口，必须重写接口中的抽象方法

class Angel implements Volant,Honest\{

@Override

public void helpOther() \{

System.out.println("我是天使，我爱帮助别人...");

@Override

public void fly() \{

System.out.println("我是天使，我可以飞...");

//好热实现善良的接口

class GoodMan implements Honest\{

@Override

public void helpOther() \{

System.out.println("我是一个爱帮助别人的人.");

//鸟人，实现飞的接口

class BirdMan implements Volant\{

@Override

public void fly() \{

System.out.println("我是鸟人，我会飞...");

总结：使用接口实现多态的步骤

1.编写接口

2.实现类实现接口中的方法

3. 接口(类型)new 实现类对象

通过面向接口编程，而不是面向实现类编程，可以大大降低程序模块间的耦合性，提高整个系统的可扩展性和和可维护性.

3. 内部类

将一个类定义在另一个类的内部，该类就称为内部类

3.1 内部类的特点：

1.内部类作为外部类的成员，可以直接访问外部类的成员 (包括 private 成员)，反之则不行

2.内部类的修饰符可以使public、protected、默认、private及static

3.内部类成员只有在内部类的范围之内是有效的

4.用内部类定义在外部类中不可访问的属性。这样就在外部 类中实现了比外部类的 private 还要小的访问权限

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

3.2内部类的分类

a.成员内部类(非静态成员内部类、静态成员内部类)

public class Outer \{

private int age = 10;//外部的成员变量

private String name = "张三";

//非静态的成员内部类

class Inner\{

int age = 20;//内部类的成员变量

public void show() \{

int age = 30;

System.out.println("内部类的局部变量age："+age);//访问内部类方法里的局部变量

System.out.println("内部类的变量age:"+this.age);//访问内部类方法里的成员变量

System.out.println("外部类的变量age："+Outer.this.age);//访问外部类的成员变量

public static void main(String\[\] args) \{

//创建内部类的对象

//1.创建外部对象

Outer outer = new Outer();

//2.使用外部类的对象名.new 内部类名称

Outer.Inner inner = new Outer().new Inner();

Outer.Inner inner2 = new Outer().new Inner();

inner.show();

b.匿名类

package com.sxt.outerandinner;

//匿名类:内部类没有名称

public class TestAnonmousClass \{

public static void main(String\[\] args) \{

//A b = new B();

//接口不能new new是A接口的匿名类

A a = new A() \{

@Override

public void test() \{

System.out.println("匿名类");

\};

interface A\{

public void test();

class B implements A\{

@Override

public void test() \{

适合那种只需要使用一次的类。比如：键盘监听操作等

c.局部内部类----定义在方法内部的，作用域只限于本方法

package com.sxt.outerandinner;

//局部内部类 在方法中的类

public class TestLocalClass \{

public void show() \{

//作用域仅限该方法

class Inner\{

public void fun() \{

System.out.println("hello world");

new Inner().fun();

4.String类的基础了解

a.String类又称作不可变字符序列，

b.String位于java.lang包中，Java程序默认导入java.lang包下的所有类

c.Java字符串就是Unicode字符序列，例如字符串“Java”就是4个Unicode字符’J’、’a’、’v’、’a’组成的

d.Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例

注意："+"连接符

当"+"运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接

String s1 = "Hello";

String s2 = "World! ";

String s = s1 + s2; //HelloWorld!

4.1 String类的常用方法

package com.sxt.string01;

public class Test01 \{

public static void main(String\[\] args) \{

//String类相当于char类型的数组，数组的长度一旦建立不可更改

String str = "abc";

String str1 = "hello world";

System.out.println(str.charAt(1)+"\\t"+str.charAt(2));//返回指定位置的字符

System.out.println(str.equals(str1));//比较内容是否相等

System.out.println(str.equalsIgnoreCase("AbC"));//忽略大小写的比较

System.out.println(str.indexOf("b"));//某个指定的字符串值在字符串中首次出现的位置,找到则返回索引，找不到则返回-1

System.out.println(str.indexOf(98));//自动类型转换

System.out.println(str1.lastIndexOf("h"));

System.out.println(str1.length());//返回字符串的长度

System.out.println(str1.replace("o","你好！"));//返回一个新串，用后者替换前者

System.out.println(str.startsWith("b"));//查找是否以某字符开头

System.out.println(str1.endsWith("d"));//查找是否以某字符结束

String \[\] arr = str1.split("o");//字符串分割，通过指定的字符串将内容分割成若干部分，并将分割后的内容保存到数组中返回

System.out.println(arr\[0\]+"\\t"+arr\[1\]+"\\t"+arr\[2\]);

System.out.println(str1.substring(3));//返回新字符串，从开始到原字符串结束

System.out.println(str1.substring(3,7));//返回新字符串，从开始到结束前一位(含头不含尾)

String str2 = "ABNx";

System.out.println(str2.toLowerCase());//返回一个新的字符串，将原字符串所有大写字母小写

System.out.println(str1.toUpperCase());//返回一个新的字符串，将原字符串所有小写字母大写

String str3 = " 你好 我是秦 ";

System.out.println(str3+"\\t"+str3.length());

String str4 = str3.trim();//去掉开头和末尾的空格

System.out.println(str4+"\\t"+str4.length());

4.2 String类中的compareto方法及String类型的构造方法

package com.sxt.string01;

public class Test02 \{

public static void main(String\[\] args) \{

String str1 = "apple";

String str2 = "banana";

String str3 = "app";

System.out.println(str1.compareTo(str2));

System.out.println(str1.compareTo(str3));

/\*String类型的构造方法\*/

String s1 = new String();//创建了一个长度为0的字符串

String s2 = null;//没有创建对象，只是生命了String类型的对象s2

String s3 = new String("hello!");

//通过char/byte类型的数组构造String对象

char\[\] c = \{'a','b','c','d'\};

String s4 = new String(c);

System.out.println("s4:"+s4);

byte\[\] b = \{97,98,99,100,101\};

String s5 = new String(b);

System.out.println("s5:"+s5);

String s6 = new String(c,2,2);//在c中下标为2的开始，取2个结束

System.out.println("s6:"+s6);

String s7 = new String(b,2,3);//在d中下标为2的开始，取3个结束

System.out.println("s7:"+s7);

4.3常量池的概念

package com.sxt.string01;

public class Test03 \{

public static void main(String\[\] args) \{

String str1 = "abc";

String str2 = "a"+"b"+"c";

String str3 = new String("abc");

String str4 = str3+"";

String str5 = new String("abc");

System.out.println("str1==str2:"+(str1==str2));

System.out.println("str1==str3:"+(str1==str3));

System.out.println("str1==str4:"+(str1==str4));

System.out.println("str1==str5:"+(str1==str5));

System.out.println("str3==str5:"+(str3==str5));

4.4字符串相等的判断

比较两个字符串内存地址是否相等用：“==”

比较两个字符串对象的内容是否相等：“equals(Object obj)”

package com.sxt.string01;

public class Test04 \{

public static void main(String\[\] args) \{

String str = "abc";

String str2 = new String("abc");

System.out.println("两个对象的地址是否相等："+(str==str2));

/\*比较对相应位置上的字符是否相等，如果所有的对象位置上的字符均相等，true；否则返回false\*/

System.out.println("两个对象的内容是否相等："+str.equals(str2));

/\*Person对象instanceof String 的结果为false，股直接返回false\*/

System.out.println("String对象与Person对象的内容是否相等："+str.equals(new Person()));

class Person\{

java抽象类重载_012 JAVA 抽象类、接口、String类的基础了解

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java基础（13）抽象类、接口

相关 Java基础：Java接口和抽象类

相关 Java的抽象类 & 接口

相关 java 抽象类和接口——抽象类

相关 java抽象类重载_012 JAVA 抽象类、接口、String类的基础了解

相关 java 抽象类、接口

相关 java 抽象类接口

相关 Java基础--接口和抽象类

相关 JAVA基础__接口、抽象类

相关 Java基础——抽象类