复习
面向过程：关注点->过程（步骤）
面向对象：关注点->对象
类和对象：
类->抽象
对象->实体
构造方法：
定义：方法名和类名相同，没有返回类型
来源：不定义->默认 public 无参
如果定义->不默认构造方法了
作用：创建对象
调用：new + 构造方法
变量的分类：
成员变量和局部变量
成员变量整个类内，局部变量局限于方法内
void f(int x){
int y;
.....(x)
}
this:
表示本类对象
this.成员
this(实参列表); 构造方法的第一条有效语句
封装：变量定义private set/get方法 构造方法
实现封装：private的 变量
提供set/get方法
继承：
子类可以继承父类所有成员（除构造方法）
extends
继承定义:
子类父类:
单一继承
Object:
is a ??
super:
父类的对象
super.成员
super(实参列表)：构造方法的第一条有效语句
-----------------------------------------------------
1.访问修饰符
private 变量，方法 本类
默认 类，变量，方法 同一个包
protected 变量，方法 同一个包，不同包（继承关系）
public 类，变量，方法 任何地方
-----------------------------------------------
2.方法重写
继承关系：
父类和子类 方法名相同，参数列表相同
方法的返回类型形同 （如果继承关系，子类的类型<=父类）
子类方法的访问修饰符>=父类
异常：子类方法的异常（非运行时异常）<=父类
什么重写 ->扩展父类方法的功能
私有方法不能被重写
3.继承关系中构造方法的调用规则
1）子类创建对象时，总是默认调用父类无参的构造方法
2）如果父类没有无参的构造方法，使用super（）调用指定的构造方法
class A{
int x ;
int y;
public A(int x,int y){
.........("A");
}
}
class B extends A{
public B(int x,int y){
super(x,y);
.........("B");
}
}
B b = new B(1,2);
----------------------------------------------------
构造方法练习
class MyClass{
int value;
}
public class TestMyClass{
public static void main(String args[]){
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass(10);
System.out.println(mc1.value);
System.out.println(mc2.value);
}
}
-------------------------------------------------
构造方法的调用
class Super{
public Super(){
System.out.println("Super()");
} Super() Sub()
public Super(String str){ Super() Sub() Sub(int)
System.out.println("Super(String)"); Super(String) Sub(String)
}
}
class Sub extends Super{
public Sub(){
System.out.println("Sub()");
}
public Sub(int i){
this();
System.out.println("Sub(int)");
}
public Sub(String str){
super(str);
System.out.println("Sub(String)");
}
}
public class TestSuperSub{
public static void main(String args[]){
Sub s1 = new Sub();
Sub s2 = new Sub(10);
Sub s3 = new Sub("hello");
}
}
------------------------------------------------------------------------
4.多态
定义：一种类型的变量可以指向不同的对象
Animal a1 = new Dog();
Animal a2 = new Bird();
编译时的多态：方法的重载
class A{
void f(){
....("f");
}
void f(int x){
....("f"+x);
}
}
A a1 = new A();
A a2 = new A();
a1.f();
a2.f(1);
运行时多态：方法的重写
在Animal 类中定义eat Dog和Bird类重写了此方法
Animal a1 = new Dog();
Animal a2 = new Biard();
a1.eat();
a2.eat();
在编译时，看变量的声明类型
运行时，如果子类重写了父类的方法，动态绑定到子类上，运行子类的方法
---------------------------------------------------------------------
多态练习：
class Super{
public void method(){
System.out.println("method() in Super");
}
public void method(int i){
System.out.println("method(int) in Super");
}
}
class Sub extends Super{
public void method(){
System.out.println("method() in Sub");
}
public void method(String str){
System.out.println("method(String) in Sub");
}
}
public class TestSuperSub{
public static void main(String args[]){
Super s = new Sub();
s.method(10);
s.method();
s.method("hello");//编译错误
}
}
-----------------------------------------------------------------------
多态的应用
方法的参数定义为父类类型或者接口类型
public void feed(Animal animal){
animal.eat();
}
对象造型：（对象强制转换）
通过instanceof判断
public void test(Animal animal){
if(animal instanceof Dog){
((Dog) animal).d();
}if(animal instanceof Bird){
((Bird) animal).b();
}
}
----------------------------------------------------------------
static：修饰变量，方法，静态块
1.修饰变量：
变量：成员-> 类变量（静态变量）： 由static修饰的成员变量
实例变量 ：没有static修饰
局部
类变量和实例变量的区别：
类变量对所有对象共享，公用
实例变量是归对象所有，不是公用
静态变量可以由类名调用
静态变量：类加载器加载类的时候初始化的
变量的初始化过程：
static int x = 5;
int x = 6;
2.修饰方法：
静态方法：由static修饰
实例方法：没有static修饰
int x = 1;
static int y = 2;
void f(){
}
static void f2(){
}
void test1(){
x = 2; //ok
y = 3;
f(); //ok
f2();
}
static void test2(){
x = 2; //error
y = 3;
f(); //error
f2();
}
静态方法是否可以重写？不能
重载？可以
继承？可以
构造方法是否可以定义静态的？不可以
静态方法是否可以使用this，super？ 不可以
3.静态块：
static{
}
写到类体中，在类加载时，执行一次
---------------------------------------------------------------------
final
abstract
interface
静态方法
class TestSuper {
public static void ma(){
System.out.println("Super ma");
}
public void mb(){
System.out.println("Super mb");
}
}
class TestSub extends TestSuper {
public static void ma(){
System.out.println("Sub ma");
}
public void mb(){
System.out.println("Sub mb");
}
}
public class Test {
public static void main(Stirng[] args){
TestSuper ts = new TestSub();
ts.ma(); //super ma
ts.mb(); //sub mb
}
}
——————————————————————————————————————————
静态块
public class A{
static int x = 9;
static{
x = 10;
y = 90;
z = 20;
}
static int y = 100;
static int z;
}
x = 10 y = 100,z = 20
public class Test｛
private static Test tester = new Test(); //step 1
private static int count1; //step 2
private static int count2 = 2; //step 3
public Test(){ //step 4
count1++;
count2++;
System.out.println("" + count1 + count2); // 1 1
}
public static Test getTester(){ //step 5
return tester;
}
public static void main(String[] args){
Test.getTester();
}
---------------------------------------------------------
静态块和构造块
父类的静态块->子类静态块->父类的构造块->父类的构造方法->
子类的构造块->子类的构造方法
class A{ 1 11 2 3 22 33
static{
........("1");
}
{
.......("2");
}
public A(){
.......("3");
}
}
class B extends A{
static{
........("11");
}
{
.......("22");
}
public B(){
.......("33");
}
}
new B();
-----------------------------------------------------------------
练习：
class A{
static D d;
static {.....("A1"); d = new D();}
{.........("A2");}
public A(){.........("A3");}
}
class B extends A{
static C c = new C();
static {.....("B1");}
{.........("B2");}
public B(){.........("B3");}}
class C{
public C(){........("C");}
}
class D extends C{
public D(){........("D");}
}
new B(); A1 C D C B1 A2 A3 B2 B3
---------------------------------------------------------
final:
final可以修饰类，方法，变量
fianl修饰的变量：常量
常量名：一般名字的所有字母都大写，如果有多个单词组成，单词之间用_
格式：final int PRICE = 10;
特点：不能改
final修饰的方法：不能重写
final修饰类：不能被继承
final 修饰的方法可以被继承
final练习
class Super{
public final void m1(){
System.out.println("m1() in Super");
}
public void m1(int i){
System.out.println("m1(int) in Super");
}
}
class Sub extends Super{
public void m1(int i){
System.out.println("m1(int) in Sub");
}
public void m1(double d){
System.out.println("m1(double) in Sub");
}
}
public class Test {
public static void main(String args[]){
Sub s = new Sub();
s.m1();
s.m1(10);
s.m1(1.5);
}
}
-------------------------------------------------------