回顾:
1.继承:
代码的重用，extends
父:共有 子类:特有
继承后，子类具有: 本类+父类
单一继承，传递性
先构造父再构造子，子类构造方法的第一句默认super()调父类无参构造
2.super:指代当前对象的父类对象
super.成员变量名
super.方法名()
super()
3.向上造型:
1)父类的引用指向子类的对象
2)能点出来什么，看引用的类型
4.方法的重写(override): 重新写，覆盖
1)父子类中，方法签名相同，方法体不同
2)重写方法被调用时，看对象的类型
class Aoo{
void a(){}
}
class Boo extends Aoo{
void a(int num){}
}----------方法的重载
正课:
1.方法的重写:
1)父子类中，方法签名相同，方法体不同
2)重写方法被调用时，看对象的类型
3)遵循"两同两小一大"规则:
3.1)两同:
方法名相同，参数列表相同
3.2)两小:
子类的返回值类型小于或等于父类-----一般都是等于
3.2.1)返回类型为void时，必须相同
3.2.2)返回类型为基本类型时，必须相同
3.2.3)返回类型为引用类型时，需小于或等于
子类抛出的异常小于或等于父类-----异常后明白了
3.3)一大:
子类的访问控制权限大于或等于父类---下午讲
2.重写与重载的区别---常见面试题
1)重写:父子类中，方法名相同，参数列表相同
遵循"运行期"绑定，看对象的类型调用方法
2)重载:一个类中，方法名相同，参数列表不同
遵循"编译期"绑定，看引用的类型绑定方法
3.package:包
1)作用:避免类的命名冲突
2)包名可以有层次结构，类完全限定名: 包名.类名
3)建议:包名所有字母都小写
import:声明类/引入类
1)语法: import 包名.类名
2)同一包中的类，可以直接访问
3)不同包中的类，有两种访问方式:
3.1)完全限定名-----繁琐(不建议)
3.2)先import声明类，直接用类名-----建议
4.访问控制修饰符:
1)public:公开的，任何地方
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
说明:
1)类的访问控制: public，默认的
2)类成员的访问控制: 如上4种都可以
建议:
数据(变量)私有化(private)，行为(方法)公开化(public)
5.static:静态的
1)静态变量:
1.1)由static修饰
1.2)属于类的，存在方法区中，只有一份
1.3)常常通过类名.来访问
1.4)何时用:所有对象的数据都一样时使用时
2)修饰方法:静态方法
2.1)由static修饰
2.2)没有隐式this传递，不能直接访问实例成员
2.3)常常通过类名.来访问
2.4)何时用:方法的操作仅与参数相关而与对象无关时使用
3)块:静态块
3.1)类被加载期间自动执行，只执行一次
3.2)何时用: 初始化静态资源(图片、音频、视频等)
6.final:最终的(不可改变)
1)修饰变量:变量不能被修改
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
7.内部类: ----此写法了解
1)类中套类，外面的类叫外部类，里面的类叫内部类
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常只在外部类中创建
4)内部类中可以直接访问外部类成员(包括私有的)
5)内部类中隐式的引用指向创建它的外部类对象
----------外部类名.this (Mama.this Outer.this)
8.匿名内部类:----掌握
1)想创建一个类的对象，并且对象还只创建一次，
这个类就没有意义了，此时，该类不必命名，
称之为匿名内部类
作业:
1.第4天的课后作业都写完
2.自学static final常量
3.每日一练
重写注意事项: 两同两小一大
重写与重载的区别
package,import
访问控制修饰符(public,private,protected,默认的)
static
final
内部类
class Test{
main(){
Aoo o1 = new Aoo();
Aoo o2 = new Aoo();
Aoo o3 = new Aoo();
}
}
class Aoo{
}
InnerDemo
class Test{
main(){
Aoo o1 = new Aoo(); //正确
Boo o2 = new Boo(); //编译错误
}
}
class Aoo{
class Boo{ //成员
}
}
第5天讲的是抽象类和接口
第6天的内部类
作业:
1.static final常量------自学
百度音乐
张三-----为你写诗.mp3
李四-----
王五-----
所有对象共享这一个mp3(static的)
c1.drop()与c2.drop()与c3.drop()
-------------最终结果不一样(与对象有关)
Cell c1 = new Cell(2,5);
c1.drop();
Cell c2 = new Cell(0,4);
c2.drop();
Cell c3 = new Cell(6,8);
c3.drop();
class Cell{
int row;
int col;
void drop(){
row++;
}
}
double d = Math.sqrt(25);
m1.sqrt(25)与m2.sqrt(25)与m3.sqrt(25)
------------最终结果都一样(与对象无关)
Math m1 = new Math();
m1.sqrt(25);
Math m2 = new Math();
m2.sqrt(25);
Math m3 = new Math();
m3.sqrt(25);
Arrays.sort(arr);
a1.sort(arr)与a2.sort(arr)与a3.sort(arr)
-----------最终结果都一样(与对象无关)
Arrays a1 = new Arrays();
a1.sort(arr);
Arrays a2 = new Arrays();
a2.sort(arr);
Arrays a3 = new Arrays();
a3.sort(arr);
class Cell{
int row;
int col; //实例变量
void drop(){
row++;
}
}
class Aoo{
int a; //实例变量，对象点来访问
static int b;
void show(){ //隐式传递this
a = 1;
b = 2;
}
static void test(){ //没有隐式this传递
a = 1; //编译错误
b = 2;
}
}
class Card{
String cardId;
String cardPwd;
double balance;
static double pir; //利率
}
Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
Student ww = new Student();
ww.name = "wangwu";
ww.age = 24;
Student.className = "JSD1507";
class Student{
static String name;
int age;
static String className;
}
静态变量:所有对象共有那一份数据
成员变量:
1.实例变量:堆中，属于对象的，有一个对象就有一份
对象点来访问
2.静态变量:方法区中，属于类的，只有一份
类名点来访问
class Cell{
int row;
int col;
}
class Aoo{
int a;
static int b;
}
你把密码告诉我吧!!!!!!
建议:
数据私有化，行为公开化
开卡:
你:身份证，填个单子
营业员: 复印两份身份证，盖两个章
复印三份身份证，盖三个章
功能的实现-----保护起来
class Card{
private String cardId;
private String cardPwd;
private double balance;
public boolean payMoney(double money){
balance -= money;
return true;
}
public boolean checkPwd(String pwd){
pwd与cardPwd对比相等与否
return true;
return false;
}
}
package a.b.c;
class Aoo{
}
class Boo{
}
class Coo{
}
package m;
import a.b.c.Aoo;
import a.b.c.*;----------不建议
class Test{
void te(){
a.b.c.Aoo o = new a.b.c.Aoo(); //完全限定名
Aoo o = new Aoo();
}
}
包名建议:
域名反写 . 项目名称 . 模块名称
com.tarena . manager . stumanager
民生银行:
A公司: A模块
B公司: B模块
C公司: C模块
A模块+B模块+C模块
A模块:
package test;
class Aoo{
}
B模块:
package test;
class Aoo{
}
500万的项目:-------1000个类
a包---10个类
package a;
class Aoo{
}
完全限定名: a.Aoo
package b;
class Aoo{
}
完全限定名: b.Aoo
引用类型之间大小关系: 父类大，子类小
Tetromino o1 = new T(); //向上造型--自动类型转换
基本数据类型的转换:
1.自动类型转换: 从小类型到大类型
2.强制类型转换: 从大类型到小类型
OverrideOverloadDemo