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{
}