1.final和static关键字
final：是一个关键字，表示最终的意思。可以用来修饰类
修饰类：表明该类是最终类，不能被继承
修饰变量：表明该变量是常量，不能再次被赋值
修饰方法：表明该方法是最终方法，不能被重写
static：是一个关键字，静态的意思。可以用来修饰成员变量和成员方法。
static修饰成员的特点：
A:被类的所有对象共享。同样也是判断这个对象是否应该用static修饰的条件。
B:可以通过类名直接访问
C:优先于对象存在
D: 随着类的加载而加载
- 非静态的成员方法：
-
能访问静态的成员变量 -
能访问非静态的成员变量 -
能访问静态的成员方法 -
能访问非静态的成员方法 - 静态的成员方法：
-
能访问静态的成员变量 -
能访问静态的成员方法
表格展示分别能访问的部分：
| 非静态的成员方法方法 | 静态的成员方法 |
|---|---|
| 静态的成员变量 | 静态的成员变量 |
| 非静态的成员变量 | |
| 静态的成员方法 | 静态的成员方法 |
| 非静态的成员方法 |
- 注意事项：
-
静态成员方法中不能出现this,super这样的关键字。 -
原因是：静态是随着类的加载而加载，this,super这样的关键字是随着对象的创建而存在。 -
先进内存的，不能访问后进内存的。
2.抽象类
- 抽象类的特点：
-
A:抽象类和抽象方法必须使用abstract关键字修饰 -
B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类 -
C:抽象类不能实例化 -
抽象类如何实例化呢? -
参照多态的方式，通过子类对象实例化。 -
D:抽象类的子类 -
要么重写抽象类中的所有抽象方法 -
要么是抽象类
成员变量：
有成员变量：
有成员变量，成员变量可以是变量，也可以是常量。
构造方法：
有构造方法
抽象类中的构造方法的作用？
用于子类访问父类数据的初始化。
成员方法：
有成员方法，成员方法可以是抽象的，也可以是非抽象的。
抽象方法：限定子类必须完成某些动作
非抽象方法：提高代码的复用性
3.接口的概述以及练习
接口的特点：
A:定义接口使用的是interface关键字
B:类和接口之间是现实关系，用implement关键字表示
C:接口不能实例化
但是接口可以通过参杂多态的形式使用实现类来实例化。
D:接口的实现类
要么重写接口中的所有的抽象方法
要么是一个抽象类
多态的几种形式：
具体类多态（几乎不用）
抽象类多态（常用）
接口类多态（最常用了）
eg：
idea创建一个Interface 的测试
idea创建一个是InterFace的jummping的接口
然后写出抽象方法
public abstract void jump；
然后用一个类和这个接口产生关系
不能写extend而是用implement
抽象类也可以但是意义不大！
接口的成员特点：
final 常量！
成员变量：
有成员变量，而且变量只能是常量。
默认修饰符：public static final
构造方法：
没有构造方法
成员方法：
有成员方法，而且都是抽象的。
默认修饰符：public abstract
所以都应该写为public abstract void method（）；
Object：是类层次结构的根类，所有的类都直接的或者间接的继承自该类。
类与类、接口与接口、类与接口
*类与类
- 继承关系，只能单继承，可以多层继承
- 类与接口：
- 实现关系，可以单实现，也可以多实现
- 还可以在继承一个类的同时实现多个接口
- 接口与接口:
- 继承关系，可以单继承，也可以多继承
抽象类和接口的区别
*A成员区别 - 抽象类：可以是变量，也可以是常量
- 构造方法：有
- 成员方法：可以是抽象方法，也可以是非抽象方法
- 接口：
- 成员变量：只能是常量
- 成员方法：只能是抽象方法
- B；关系区别
- 类与类：继承关系，只能单继承，可以多层继承
- 类与接口：实现关系，可以单实现，也可以多实现
- 接口与接口：继承关系，可以单继承，也可以多继承
- C：设计理论的区别
- 抽象类被继承体系的是“is a” 抽象类中定义的是继承体系的共性功能
- 接口被实现体现的是：“like a“ 接口中定义的是该体系的扩展功能
- 举例
- 猫：动物
- 猫：跳高运动员
练习：
需求：猫狗案例,让所有的猫狗具备跳高的额外功能 - 分析：从具体到抽象
-
猫：姓名，年龄，吃饭(){} -
狗：姓名，年龄，吃饭(){} -
发现了共性的内容，就提取了一个父类。 -
抽象动物类： -
姓名，年龄，吃饭(); -
猫：继承动物类 -
狗：继承动物类 -
跳高的额外功能是一个扩展功能，所以应该定义接口实现。 -
跳高接口： -
跳高(); -
猫：继承动物类,实现跳高接口 -
狗：继承动物类,实现跳高接口 - 实现：从抽象到具体
- 使用：使用的是具体的类的对象
- 作业：具体的狗类，模仿着猫类给出。
-
狗类的测试，也模仿着猫类的测试给出。
1.猫狗共性所以建立一个父类 Animal
public abstract class Animal {
//给出姓名年龄
private String name;
private int age;
//无参和带参构造方法
public Animal(){}
public Animal(String name,int age){
this.name=name;
this.age =age;
}
//get set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象的吃饭方法
public abstract void eat();
2.建立猫类Cat
public class Cat extends Animal implements Jummp{
public Cat(){}
public Cat(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void Jump() {
System.out.println("猫跳高");
}
}
狗一样
public class Dog extends Animal implements Jummp{
public Dog(){}
public Dog(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void Jump() {
System.out.println("狗跳高");
}
}
跳高是额外的建立一个接口
public interface Jummp {
public abstract void Jump();
}
测试
public class InterfaceTest {
public static void main(String[] args) {
Cat c = new Cat();
c.setName("暹罗猫");
c.setAge(2);
System.out.println(c.getAge()+"--**"+c.getName());
c.eat();
c.Jump();
System.out.println("*****");
Cat c2 = new Cat("暹罗猫",2);
System.out.println(c2.getName()+"***"+c2.getAge());
c2.eat();
c2.Jump();
System.out.println("------------");
Dog d = new Dog();
d.setName("二狗");
d.setAge(5);
System.out.println(d.getAge()+"----"+d.getName());
d.eat();
d.Jump();
System.out.println("----");
Dog d2 = new Dog("二狗",5);
System.out.println(d2.getAge()+"----"+d2.getName());
d2.eat();
d2.Jump();
}
}
练习二
1.新建person类
public abstract class Person {
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
1.0新建接口学英语
public interface SpeakEnglish {
public abstract void speak();
}
2.新建运动员类`
public abstract class Player extends Person{
public Player(){}
public Player(String name,int age){
super(name,age);
}
public abstract void study();
}
3.新建教练类
public abstract class Coach extends Person {
public Coach(){}
public Coach(String name,int age){
super(name,age);
}
public abstract void Teach();
}
4.新建乒乓球运动员类
public class PingpangPlayer extends Player implements SpeakEnglish{
public PingpangPlayer(){}
public PingpangPlayer(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("乒乓球运动员吃白菜");
}
@Override
public void study() {
System.out.println("乒乓球运动员学接球和发球");
}
@Override
public void speak() {
System.out.println("乒乓球运动员学英语");
}
}
5.篮球运动员类
public class basketballPlayers extends Player {
public basketballPlayers(){}
public basketballPlayers(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println("篮球运动员吃牛排");
}
@Override
public void study() {
System.out.println("篮球运动员学习运球");
}
}
5…0教练类
public abstract class Coach extends Person {
public Coach(){}
public Coach(String name,int age){
super(name,age);
}
public abstract void Teach();
}
6.新建乒乓球教练类
public class PingpangCoach extends Coach implements SpeakEnglish{
public PingpangCoach(){}
public PingpangCoach(String name,int age){
super(name,age);
}
@Override
public void Teach() {
System.out.println("乒乓球教练教发球");
}
@Override
public void eat() {
System.out.println("乒乓球教练吃白菜");
}
@Override
public void speak() {
System.out.println("乒乓球教练说英语");
}
}
7.篮球教练
public class BasketballCoach extends Coach{
public BasketballCoach(){}
public BasketballCoach(String name,int age){
super(name,age);
}
@Override
public void Teach() {
System.out.println("篮球教练吃牛排");
}
@Override
public void eat() {
System.out.println("篮球教练吃牛排");
}
}
8.测试
public class InterfaceTest {
public static void main(String[] args) {
PingpangPlayer p =new PingpangPlayer();
p.setName("马龙");
p.setAge(23);
System.out.println(p.getName()+p.getAge());
p.eat();
p.speak();
p.study();
System.out.println("----------");
PingpangCoach pp =new PingpangCoach();
pp.setName("张继科");
pp.setAge(56);
System.out.println(p.getAge()+p.getName());
pp.eat();
pp.speak();
pp.Teach();
System.out.println("--------------");
basketballPlayers b =new basketballPlayers();
b.setName("林书豪");
b.setAge(18);
System.out.println(b.getAge()+b.getName());
b.eat();
b.study();
System.out.println("------------");
BasketballCoach B =new BasketballCoach();
B.setName("科比");
B.setAge(65);
System.out.println(B.getAge()+B.getName());
B.Teach();
B.eat();
4.包的概述和权限修饰符
包：就是文件夹
作用：就是对类的分类管理。
举例：
按照功能分
按照模块分
包的定义格式：
package 包名；
如果是多级包用.隔开
注意事项：
A:package必须是程序的第一条可执行语句
B: package语句在一个Java文件中只能有一个
导包：
import 包名(路径和包名和类)；
权限修饰符
权限修饰符：
扫一扫
4519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
