1.super关键字
只能用于继承,并在子类中使用。代表的意思是父类对象
this:
代表当前类对象。
可以调用属性和方法
可以调用构造方法
super:
代表是父类的对象
可以调用父类的成员变量和成员方法
注意事项:当super调用属性的时候,就是内存里面那一个
可以调用父类的构造方法
真实开发的时候, super.父类的方法。证明在调用父类的方法
class Father1 {
String name;
public Father1 () {
System.out.println("Father1的无参构造");
}
public Father1 (String name) {
System.out.println("Father1有参构造");
}
}
class Son1 extends Father1 {
//在子类中无论你写了有参构造和无参构造,都要去执行父类的无参构造
//除非你自己调用父类有参构造方法
public Son1(String name) {
//在调用父类的无参构造方法
//super();
super("狗蛋");
}
}
public class Demo2 {
public static void main(String[] args) {
Son1 son1 = new Son1("狗蛋");
}
}
2.抽象类【重要】
在面向对象中,所有的对象可以通过类来创建。反过来说,并不是所有的类都可以创建象的。如果一个类中没有足够完整的信息来描述具体的对象的话,那么这个类叫抽象类。在Java中使用关键字abstract修饰类,这个类叫抽象类。
2.1 abstract关键字
abstract修饰的类叫抽象类
abstract修饰的方法叫抽象方法
总结:abstract 只能修饰类和方法
语法格式:
abstarct class 类名{
普通的方法;
public void eat () {
}
抽象方法;
public abstarct void sleep ();
}
入门案例:
先学会说声明出来一个抽象类
//声明一个抽象类
abstract class Person {
//在抽象类中可以写普通成员方法
public void eat () {
System.out.println("今天中午吃外卖。。。。。。");
}
//定义一个抽象方法 抽象方法是不完整的方法 是没有方法体的
abstract public void work();
}
//定义了咋用啊? 抽象类创建不了对象的 咋解决?
//解决方案: 再写一个普通类去继承抽象类即可
class Man extends Person {
//the type Man must implement the inherited
//abstract method Person.work()
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("劳动力");
}
}
public class Demo1 {
public static void main(String[] args) {
Man man = new Man();
man.eat();
man.work();
}
}
2.2 抽象类的使用
抽象类创建不了对象,不能被实例化
解决方案: 再写一个普通类去继承抽象类即可
2.3 abstract注意事项:
1.如果一个类中用abstract修饰的话,那么这个类叫抽象类
2.抽象类中可以有普通成员方法和抽象方法
3.抽象方法没有方法体,是不完整的方法
4.抽象类不能被实例化
5.写一个普通的类去继承抽象类
6.在子类中一定去实现(重写)抽象类中所有的抽象方法
7.非抽象方法可以重写也可以不重写
8.一个抽象类能不能去继承另外一个抽象类? 可以的!!!
9.抽象类可以继承非抽象类
class Cell {
public void add () {
System.out.println("分裂");
}
}
abstract class Animal extends Cell{
public abstract void run();
}
abstract class Monkey extends Animal{//抽象类
public void call () {//普通的成员方法
System.out.println("咿咿呀呀.......");
}
public abstract void eat();
public abstract void sleep();
}
class People extends Monkey {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃肉!!!");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("躺着睡。。。");
}
@Override
public void call() {
System.out.println("嘻嘻哈哈说话");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("人站立奔跑。。。");
}
}
public class Demo2 {
public static void main(String[] args) {
People people = new People();
people.add();
}
}
3. final 关键字
final中文意思: 修饰符
最终的,最后的
用法:
1. final可以修饰成员变量
使用final修饰的成员变量,一定要赋值(初始化),而且不能修改。
2. final可以修饰局部变量
使用final修饰局部变量的时候,可以先对变量不赋值,使用之前进行赋值。
但是一旦赋值以后就无法更改。
3.final可以修饰成员方法
final修饰的成员方法不能被重写,牵涉到继承
4.final可以修饰一个类
final修饰的类不能被继承
5.final可以修饰对象的引用
修饰对象引用 一旦被赋值 就无法改变
class Person {
final String name = "狗蛋";
public void test () {
final int i;
i = 30;
//i = 80;//一旦被赋值,就无法改变了
System.out.println(i);
}
public final void eat () {
System.out.println("吃饭");
}
}
//class Man extends Person {
// @Override
// public void eat() {
// System.out.println("吃的多");
// }
//}
public class Demo1 {
public static void main(String[] args) {
final Person person = new Person();
System.out.println("Person:" + person);
//一旦使用final修饰person 对象引用 是一个固定的内存地址
Person person1 = new Person();
System.out.println("Person1:"+ person1);
//person.name = "嘻嘻";
//person = person1;//将person1赋值给了person对象
System.out.println(person);
}
}
4. 接口【重要】
4.1 Java中接口
语法格式:
interface 接口名字 {
成员变量
成员方法
}
4.2 实现接口 使用关键字implements
interface A {
//接口下面的属性都是常量 常量是使用static 和final修饰的
//只不过在接口中把 static和fianls省去了 常量的名字都要大写
String NAME = "狗蛋";
//在接口一般不写属性的!!!
//成员方法 在接口中全部是抽象的方法
public void eat ();
public void sleep();
}
//无法实例化接口A ,咋办?新建一个类去实现(implements)接口
class TestA implements A {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃好饭");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("睡好觉");
}
}
public class Demo1 {
public static void main(String[] args) {
TestA testA = new TestA();
testA.eat();
testA.sleep();
System.out.println(testA.NAME);
}
}
接口的注意事项:
1.使用关键字 interface 声明出来一个接口
2.接口面可以有属性,但是是static 和final修饰的属性。被称为常量。几乎不用
3.接口下面全部抽象的方法,不带方法体的
4. jdk1.8以后是可以有默认(default)的方法的,这个默认方法带有方法体【重点!!!】
5.接口下面没有构造方法,不能被实例化
6.去使用一个普通的类去实现这个接口,使用关键字implements
7.一定要在实现类中去实现所有的抽象方法
8.一个普通的类可以实现多个接口,弥补了单继承的局限性
9.一个接口可以去继承另外一个接口
interface B2 {
public void work();
}
interface B1 extends B2{
public void smoking();
}
interface A1 {
String NAME = "狗蛋";
public void test();
public void eat();
public default void sleep () {
System.out.println("睡觉睡得啥也不知道");
}
}
class TestA1 implements A1, B1{
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("测试");
}
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃东西");
}
@Override
public void sleep() {
System.out.println("睡得什么都不会了");
}
@Override
public void smoking() {
// TODO Auto-generated method stub
System.out.println("不要在整栋楼抽烟!!!");
}
@Override
public void work() {
// TODO Auto-generated method stub
}
}
public class Demo2 {
public static void main(String[] args) {
TestA1 testA1 = new TestA1();
testA1.eat();
testA1.test();
testA1.sleep();
}
}