面向对象的概述：
1.用java语言对现实生活中的事物进行描述。通过类的形式来体现的。
2.怎么描述呢？
对于事物描述通常只关注两方面。
一个是属性，一个是行为。
3.成员变量和局部变量的区别：
①成员变量定义在类中，整个类中都可以访问。局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
②成员变量存在于堆内存的对象中。局部变量存在于栈内存的方法中。
③成员变量随着对象的创建而存在，随着对象的消失而消失。局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
④成员变量都有默认初始化值。局部变量没有默认初始化值。
4.类的使用
①在计算机中创建一个car的实例。通过new关键字。
Car c = new Car();// c就是一个类类型的引用变量，指向了该类的对象。
//匿名对象：只使用一次的对象
c.run(); //要使用对象中的内容可以通过 对象.成员 的形式来完成调用。
/*匿名对象。没有名字的对象 。
new Car();//匿名对象。其实就是定义对象的简写格式。*/
1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
new Car().num = 5;
new Car().color = "green";
new Car().run();
2，匿名对象可以作为实际参数进行传递。
*/
// Car c1 = new Car();
// show(c1);
show(new Car());
public static void show(Car c)//类类型的变量一定指向对象。要不就是null。 { c.num = 3; c.color = "black"; System.out.println(c.num+"..."+c.color); }
5.主函数
/* public static void main(String[] args) 主函数特殊之处： 1，格式是固定的。 2，被jvm所识别和调用。 public:因为权限必须是最大的。 static:不需要对象的,直接用主函数所属类名调用即可。 void：主函数没有具体的返回值。 main:函数名，不是关键字，只是一个jvm识别的固定的名字。 String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。 */ class MainDemo { public static void main(String[] args) //new String[0] { /**/ // System.out.println(args);//[Ljava.lang.String;@c17164 System.out.println(args.length); for(int x=0; x<args.length; x++) System.out.println(args[x]); } }
6.new关键字
一、面向对象
- 1.面向对象概念
- 2.类与对象的关系
- 3.封装
- 类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。
- 类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
- 4.构造函数
- 构造方法定义：构造方法是为类中的属性初始化的。
-
构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。
创建对象都必须要通过构造函数初始化。 -
一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。 - 一般函数和构造函数什么区别呢？
-
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。构造函数：对象创建时，会调用只调用一次。
一般函数：对象创建后，可以被调用多次。 - 什么时候定义构造函数呢？
-
在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。
构造函数可以有多个，用于对不同的对象进行针对性的初始化.
多个构造函数在类中是以重载的形式来体现的。 - 细节：
-
1，构造函数如果完成了set功能。set方法是否需要。
2，一般函数不能直接调用构造函数。
3，构造函数如果前面加了void就变成了一般函数。
4，构造函数中是有return语句的。 -
View Code
class Person { private String name; private int age; //定义一个Person类的构造函数。 Person()//构造函数，而且是空参数的。 { name = "baby"; age = 1; System.out.println("person run"); } //如果有的孩子一出生就有名字。 Person(String n) { name = n; } public void setName(String n) { name = n; } Person(String n,int a) { name = n; age = a; } public void speak() { System.out.println(name+":"+age); } }
- 5.this关键字
- 当成员变量和局部变量重名，可以用关键字this来区分。
this : 代表对象。代表哪个对象呢？当前对象。
this就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。
View Codeclass Person { private String name; private int age; Person() { name = "baby"; age = 1; System.out.println("person run"); } Person(String name) { this(); this.name = name; } Person(String name,int age) { this.name = name; this.age = age; } public void speak() { System.out.println(this.name+":"+this.age); } /* 判断是否是同龄人。 */ public boolean compare(Person p) { /* if(this.age==p.age) return true; else return false; */ return this.age==p.age; } } class ThisDemo { public static void main(String[] args) { Person p1 = new Person("aa",30);// Person p2 = new Person("zz",12); p2.compare(p1); // new Person(); // Person p = new Person("旺财",30); // p.speak(); // Person p1 = new Person("小强"); // p1.speak(); } }
- 当成员变量和局部变量重名，可以用关键字this来区分。
- 6.static关键字
- static的特点：
- 1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
5，static修饰的数据是共享数据，对象中的存储的是特有数据。 - 成员变量和静态变量的区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据. -
静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。 -
View Code
class Person { String name;//成员变量，实例变量 static String country = "CN";//静态变量。类变量 public void show() { System.out.println(Person.country+":"+this.name); } }
- 静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义。 -
View Code
class Demo { int age ; static int num = 9; Demo(int age) { this.age = age; } public static void speak() { System.out.println(num); } public void show() { System.out.println(age); } } class StaticDemo3 { public static void main(String[] args) { // Demo d = new Demo(30); // d.speak(); Demo.speak(); // System.out.println("Hello World!"); } }
- 静态代码块。
随着类的加载而执行。而且只执行一次。
作用：
用于给类进行初始化。
View Codeclass StaticCode { static int num ; static { num = 10; // num *=3; System.out.println("hahahah"); } StaticCode(){} static void show() { System.out.println(num); } } class Person { private String name; {//构造代码块。可以给所有对象进行初始化的。 System.out.println("constructor code "); // cry(); } static { System.out.println("static code"); } Person()//是给对应的对象进行针对性的初始化。 { name = "baby"; // cry(); } Person(String name) { this.name = name; // cry(); } public void cry() { System.out.println("哇哇"); } public void speak() { System.out.println("name:"+name); } static void show() { System.out.println("show run"); } } class StaticCodeDemo { static { // System.out.println("a"); } public static void main(String[] args) { // Person p = null; // p.speak(); // Person.show(); // Person p1 = new Person(); // p1.speak(); // Person p2 = new Person("旺财"); // p2.speak(); // new Person(); // new StaticCode().show(); // new StaticCode().show(); // StaticCode.show(); // System.out.println("b"); } }
- 7.单例设计模式
设计模式：对问题行之有效的解决方式。其实它是一种思想。
1,单例设计模式。
解决的问题：就是可以保证一个类在内存中的对象唯一性。必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。步骤：
1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。 -
View Code
//饿汉式 class Single//类一加载，对象就已经存在了。 { private static Single s = new Single(); private Single(){} public static Single getInstance() { return s; } } //懒汉式 class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。 //延迟加载形式。 { private static Single2 s = null; private Single2(){} public static Single2 getInstance() { if(s==null) s = new Single2(); return s; } } class SingleDemo { public static void main(String[] args) { Single s1 = Single.getInstance(); Single s2 = Single.getInstance(); System.out.println(s1==s2); // Single ss = Single.s; // Test t1 = new Test(); // Test t2 = new Test(); Test t1 = Test.getInstance(); Test t2 = Test.getInstance(); t1.setNum(10); t2.setNum(20); System.out.println(t1.getNum()); System.out.println(t2.getNum()); } } class Test { private int num; private static Test t = new Test(); private Test(){} public static Test getInstance() { return t; } public void setNum(int num) { this.num = num; } public int getNum() { return num; } }
二、继承
- 1.继承的概述
- 继承的好处：
1，提高了代码的复用性。
2，让类与类之间产生了关系，给第三个特征多态提供了前提. -
java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类(java中不允许,进行改良)
不直接支持，因为多个父类中有相同成员，会产生调用不确定性。
在java中是通过"多实现"的方式来体现。 -
java支持多层(多重)继承。
C继承B，B继承A。
就会出现继承体系。当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用。 -
View Code
class Demo { void show1(){} } class DemoA extends Demo { // void show1(){} void show2(){} } class DemoB extends Demo { // void show1(){} void show3(){} } 什么时候定义继承呢？ 当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy 所属关系： is a 关系。 */ /* class A { void show() { System.out.println("a"); } } class B { void show() { System.out.println("b"); } } class C extends A,B { } new C().show(); */ class Person { String name; int age; } class Student extends/*继承*/ Person { // String name; // int age; void study() { System.out.println(name+"...student study.."+age); } } class Worker extends Person { // String name; // int age; void work() { System.out.println("worker work"); } } class ExtendsDemo { public static void main(String[] args) { Student s = new Student(); s.name= "zhangsan"; s.age = 22; s.study(); } }
-
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
this和super的用法很相似。
this:代表一个本类对象的引用。
super：代表一个父类空间。 -
View Code
class Fu { private int num = 4; public int getNum() { return num; } } class Zi extends Fu { private int num = 5; void show() { System.out.println(this.num+"....."+super.getNum()); } } class ExtendsDemo2 { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
- 成员函数。
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这时函数在子父类中的特性。 - 函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override - 覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
2，静态只能覆盖静态，或被静态覆盖。 -
View Code
class Fu { public static void show() { System.out.println("fu show run"); } } class Zi extends Fu { public static void show() { System.out.println("Zi show run"); } } class ExtendsDemo3 { public static void main(String[] args) { // Zi z = new Zi(); // z.show(); NewPhone p = new NewPhone(); p.show(); p.call(); } } /* 什么时候使用覆盖操作? 当对一个类进行子类的扩展时，子类需要保留父类的功能声明， 但是要定义子类中该功能的特有内容时，就使用覆盖操作完成. */ class honeP { void call() {} void show() { System.out.println("number"); } } class NewPhone extends Phone { void show() { System.out.println("name"); System.out.println("pic"); super.show(); } }
- 子父类中的构造函数的特点。
在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
- 为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类中的构造函数。
为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用
父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，
那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。 -
View Code
class Fu { int num ; Fu() { num =10; System.out.println("A fu run"); } Fu(int x) { System.out.println("B fu run..."+x); } } class Zi extends Fu { int num; Zi() { //super();//调用的就是父类中的空参数的构造函数。 System.out.println("C zi run"+num); } Zi(int x) { this(); //super(); // super(x); System.out.println("D zi run "+x); } } class ExtendsDemo4 { public static void main(String[] args) { new Zi(6); } } class Demo//extends Object { /* Demo() { super(); return; } */ }
- 继承的好处：
- 2.继承的特点
- 3.super关键字
- 4.函数覆盖
- 5.子类的实例化过程
- 一个对象实例化过程：
Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.
View Codeclass Fu { Fu() { super(); show(); return; } void show() { System.out.println("fu show"); } } class Zi extends Fu { int num = 8; Zi() { super(); //-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后， //才进行子类的成员变量显示初始化。 System.out.println("zi cons run...."+num); return; } void show() { System.out.println("zi show..."+num); } } class ExtendsDemo5 { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
- 一个对象实例化过程：
- 6.final关键字
- 继承弊端：打破了封装性。
- final关键字：
1，final是一个修饰符，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能赋值一次。
为什么要用final修饰变量。其实在程序如果一个数据是固定的，
那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。
而且这个变量名称的值不能变化，所以加上final固定。写法规范：常量所有字母都大写，多个单词，中间用_连接。
View Codeclass Fu { void method() { //调用了底层系统的资源。 } } class Zi extends Fu { public static final double MY_PI = 3.14; static final int x = 7; void method() { // final int x = 9; // x = 9; final int NUMBER = 9; System.out.println(MY_PI); } } class FinalDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
- 7.抽象类
-
抽象类：
抽象：笼统，模糊，看不懂！不具体。 -
特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。 -
1，抽象类中有构造函数吗？
有，用于给子类对象进行初始化。 -
2，抽象类可以不定义抽象方法吗？
可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。 -
View Code
abstract class Demo { void show1() {} void show2() {} }
- 3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行 - 4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
抽象类不可以被实例化。 - 5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。
-
View Code
abstract class Demo { abstract /*抽象*/ void show(); } /* class DemoA extends Demo { void show() { System.out.println("demoa show"); } } class DemoB extends Demo { void show() { System.out.println("demob show"); } } */ abstract class 犬科 { abstract void 吼叫(); } class 狗 extends 犬科 { void 吼叫() { System.out.println("汪汪"); } } class 狼 extends 犬科 { void 吼叫() { System.out.println("嗷嗷"); } } class AbstractDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
-
View Code
/* 雇员示例： 需求：公司中程序员有姓名，工号，薪水，工作内容。 项目经理除了有姓名，工号，薪水，还有奖金，工作内容。 对给出需求进行数据建模。 分析： 在这个问题领域中，先找出涉及的对象。 通过名词提炼法。 程序员： 属性：姓名，工号，薪水、 行为：工作。 经理： 属性：姓名，工号，薪水，奖金。 行为：工作。 程序员和经理不存在着直接继承关系， 但是程序员和经理却具有共性内容。 可以进行抽取。因为他们都是公司的雇员 可以将程序员和经理进行抽取.建立体系. */ //描述雇员。 abstract class Employee { private String name; private String id; private double pay; Employee(String name,String id,double pay) { this.name = name; this.id = id; this.pay = pay; } public abstract void work(); } //描述程序员。 class Programmer extends Employee { Programmer(String name,String id,double pay) { super(name,id,pay); } public void work() { System.out.println("code..."); } } //描述经理。 class Manager extends Employee { private int bonus; Manager(String name,String id,double pay,int bonus) { super(name,id,pay); this.bonus = bonus; } public void work() { System.out.println("manage"); } } class AbstractTest { public static void main(String[] args) { System.out.println("Hello World!"); } } class Person { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } } class Student extends Person { Student(String name,int age) { super(name,age); } } class Worker extends Person { Worker(String name,int age) { super(name,age); } }
-
- 8.接口
-
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 interface。 -
定义接口使用的关键字不是class，是interface.
-
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public static final
2，抽象方法。public abstract
由此得出结论，接口中的成员都是公共的权限.
View Codeinterface Demo { public static final int NUM = 4; public abstract void show1(); public abstract void show2(); }
-
类与类之间是继承关系，类与接口直接是实现关系。
接口不可以实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。
View Codeclass DemoImpl implements /*实现*/Demo { public void show1() {} public void show2() { } }
-
在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。一个类可以实现多个接口。
View Codeinterface A { public void show(); } interface Z { public int add(int a,int b); } class Test implements A,Z//多实现 { public int add(int a,int b) { return a+b+3; } /**/ public void show(){} }
-
一个类在继承另一个类的同时，还可以实现多个接口。
View Codeclass Q { public void method() {} } abstract class Test2 extends Q implements A,Z { }
-
接口的出现避免了单继承的局限性。
View Codeinterface CC { void show(); } interface MM { void method(); } interface QQ extends CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 { void function(); } class WW implements QQ { //覆盖3个方法。 public void show(){} public void method(){} public void function(){} } class InterfaceDemo { public static void main(String[] args) { Test t = new Test(); t.show(); // DemoImpl d = new DemoImpl(); // System.out.println(d.NUM); // System.out.println(DemoImpl.NUM); // System.out.println(Demo.NUM); } }
-
抽象类和接口的异同点：
相同点：
都是不断向上抽取而来的。不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
接口的实现是 like a 关系，在定义体系额外功能。
View Code//犬按功能分：有导盲犬，搜爆犬。 abstract class 犬 { abstract void 吼叫(); } //abstract class 导盲 interface 导盲 { abstract void 导盲(); } class 导盲犬 extends 犬 implements 导盲 { public void 吼叫() { } public void 导盲(){} } //在不同的问题领域中，有不同的分析方式。 /* 学员： 学习。 抽烟学员 烟民。*/
-
三、多态
- 1.定义
-
对象的多态性。
class 动物
{}class 猫 extends 动物
{}class 狗 extends 动物
{}猫 x = new 猫();
动物 x = new 猫();//一个对象，两种形态。 -
猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。简单说：就是一个对象对应着不同类型.
多态在代码中的体现：
父类或者接口的引用指向其子类的对象。多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。多态的前提：
1，必须有关系，继承，实现。
2，要有覆盖。
View Codeabstract class Animal { abstract void eat(); } class Dog extends Animal { void eat() { System.out.println("啃骨头"); } void lookHome() { System.out.println("看家"); } } class Cat extends Animal { void eat() { System.out.println("吃鱼"); } void catchMouse() { System.out.println("抓老鼠"); } } class Pig extends Animal { void eat() { System.out.println("饲料"); } void gongDi() { System.out.println("拱地"); } } class DuoTaiDemo { public static void main(String[] args) { // Cat c = new Cat(); // c.eat(); // c.catchMouse(); Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。 //作用就是限制对特有功能的访问。 //专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。 // a.eat(); //如果还想用具体动物猫的特有功能。 //你可以将该对象进行向下转型。 // Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。 // c.eat(); // c.catchMouse(); // 注意：对于转型，自始自终都是子类对象在做着类型的变化。 // Animal a1 = new Dog(); // Cat c1 = (Cat)a1;//ClassCastException /* Cat c = new Cat(); // Dog d = new Dog(); // c.eat(); method(c); // method(d); // method(new Pig()); */ method(new Dog()); } public static void method(Animal a)//Animal a = new Dog(); { a.eat(); if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断 // //通常在向下转型前用于健壮性的判断。 { Cat c = (Cat)a; c.catchMouse(); } else if(a instanceof Dog) { Dog d = (Dog)a; d.lookHome(); } else { } } /* public static void method(Cat c) { c.eat(); } public static void method(Dog d) { } */ }
View Code/* 毕老师和毕姥爷的故事。 */ class 毕姥爷 { void 讲课() { System.out.println("管理"); } void 钓鱼() { System.out.println("钓鱼"); } } class 毕老师 extends 毕姥爷 { void 讲课() { System.out.println("Java"); } void 看电影() { System.out.println("看电影"); } } class DuoTaiDemo2 { public static void main(String[] args) { // 毕老师 x = new 毕老师(); // x.讲课(); // x.看电影(); 毕姥爷 x = new 毕老师(); x.讲课(); x.钓鱼(); 毕老师 y = (毕老师)x;//ClassCastException y.看电影(); } }
-
- 2.特点
-
多态时，
成员的特点：
1，成员变量。
编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。哦了。
作为了解。2，成员函数(非静态)。
编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。因为成员函数存在覆盖特性。
3，静态函数。
编译时：参考引用型变量所属的类中的是否有调用的静态方法。
运行时：参考引用型变量所属的类中的是否有调用的静态方法。
简单说，编译和运行都看左边。其实对于静态方法，是不需要对象的。直接用类名调用即可。
View Codeclass Fu { // int num = 3; void show() { System.out.println("fu show"); } static void method() { System.out.println("fu static method"); } } class Zi extends Fu { // int num = 4; void show() { System.out.println("zi show"); } static void method() { System.out.println("zi static method"); } } class DuoTaiDemo3 { public static void main(String[] args) { Fu.method(); Zi.method(); Fu f = new Zi();// // f.method(); // f.show(); // System.out.println(f.num); // Zi z = new Zi(); // System.out.println(z.num); } }
-
- 3.内部类
- 内部类访问特点：
1，内部类可以直接访问外部类中的成员。
2，外部类要访问内部类，必须建立内部类的对象。一把用于类的设计。
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。
这时就是还有的事物定义成内部类来描述
View Codeclass Outer { private static int num = 31; class Inner// 内部类。 { void show() { System.out.println("show run..."+num); } /*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。 { System.out.println("function run ...."+num); } */ } public void method() { Inner in = new Inner(); in.show(); } } class InnerClassDemo { public static void main(String[] args) { // Outer out = new Outer(); // out.method(); //直接访问外部类中的内部类中的成员。 // Outer.Inner in = new Outer().new Inner(); // in.show(); //如果内部类是静态的。 相当于一个外部类 // Outer.Inner in = new Outer.Inner(); // in.show(); //如果内部类是静态的，成员是静态的。 // Outer.Inner.function(); } }
- 内部类访问特点：
- 4.内部类的位置
-
为什么内部类能直接访问外部类中成员呢？
那是因为内部类持有了外部类的引用。 外部类名.this
View Codeclass Outer { int num = 3; class Inner { int num = 4; void show() { int num = 5; System.out.println(Outer.this.num); } } void method() { new Inner().show(); } } class InnerClassDemo2 { public static void main(String[] args) { new Outer().method(); } }
-
内部类可以存放在局部位置上。
内部类在局部位置上只能访问局部中被final修饰的局部变量。
View Codeclass Outer { int num = 3; Object method() { final int x = 9; class Inner { public String toString() { return "show ..."+x; } } Object in = new Inner(); return in;//0x0045 // in.show(); } } class InnerClassDemo3 { public static void main(String[] args) { Outer out = new Outer(); Object obj = out.method(); System.out.println(obj); } } /* class Fu extends Object { } class zi extends Fu { } Fu f = new zi(); Object o = new Fu();
-
- 5.匿名内部类
-
匿名内部类。就是内部类的简写格式。
必须有前提：
内部类必须继承或者实现一个外部类或者接口。匿名内部类：其实就是一个匿名子类对象。
格式：new 父类or接口(){子类内容}
-
View Code
abstract class Demo { abstract void show(); } class Outer { int num = 4; /* class Inner extends Demo { void show() { System.out.println("show ..."+num); } } */ public void method() { //new Inner().show(); new Demo()//匿名内部类。 { void show() { System.out.println("show ........"+num); } }.show(); } } class InnerClassDemo4 { public static void main(String[] args) { new Outer().method(); } }
View Codeinterface Inter { void show1(); void show2(); } class Outer { /* class Inner implements Inter { public void show1() { } public void show2() { } } */ public void method() { // Inner in = new Inner(); // in.show1(); // in.show2(); Inter in = new Inter() { public void show1() { } public void show2() { } }; in.show1(); in.show2(); } } /* 通常的使用场景之一： 当函数参数是接口类型时，而且接口中的方法不超过三个。 可以用匿名内部类作为实际参数进行传递 */ class InnerClassDemo5 { class Inner { } public static void main(String[] args) { System.out.println("Hello World!"); /* show(new Inter() { public void show1(){} public void show2(){} }); */ // new Inner(); } public void method() { new Inner(); } public static void show(Inter in) { in.show1(); in.show2(); } }
View Codeclass Outer { void method() { Object obj = new Object() { public void show() { System.out.println("show run"); } }; obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型。 //这样就不能在使用子类特有的方法了。 } } class InnerClassDemo6 { public static void main(String[] args) { new Outer().method(); } }
View Codeinterface Inter { void show(); } class Outer { //补足代码 (建议用匿名内部类) static Inter method() { return new Inter() { public void show(){} }; } } /* class haha implements Inter { public void show(){} } */ class InnerClassTest { public static void main(String[] args) { Outer.method().show(); } }
-
- 6.异常
- 7.throwable中的方法
- 8.异常处理
- 9.自定义异常
- 10.异常细节
- 11.包
- 12.包之间的访问
- 13.四种权限
- 14.import
- 15.jar
- 16.jar包的操作