马士兵Java视频第三章总结
2015-08-25 09:11
567 查看
写出以下关键词的含义、用法、并附上经过调试无误的实例。
●常用的类:public StringgetName() ;当属性设为private
●在继承中注意:
public class Vehicle {...}
public class Car extends Vehicle {...}
public class SUV extends Car {...}
则Vehicle v = new SUV();是正确的。
●内存中分四块:
堆:对象生成时(属性)。
栈:局部变量
Code segment:方法。
Data segment:静态常量
●一般和构造方法一起使用
其中dog就是对象的引用,在栈内存中存在,存放的是dog对象在堆内存中的地址。
●拓展:单例模式等,构造函数的权限不同,用法不同。
实例程序:
输出结果:David
1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int, float),但是不能为fun(int, int));
2、不能重载只有返回值不同的方法名。因为返回值区分不出来。
3、存在于父类和子类、同类中。
4、不能通过访问权限、返回类型、抛出的异常进行重载;
特点:
1、方法名、参数、返回值相同。
2、子类方法不能缩小父类方法的访问权限。
3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;
5、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。
实例程序:
结果:
p1的名字是:Chirstina
p2的名字是:Sanpao。他的年龄是:25
name = Monday. age = 20. school = ss
条件:
1、 要用继承
2、 要用重写
3、 父类引用指向子类对象
实例程序:
2、把子类对象直接赋给父类引用叫upcasting向上转型,向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting),要强制转型。
如father就是一个指向子类对象的父类引用,把father赋给子类引用son 即Son son =(Son)father;
其中father前面的(Son)必须添加,进行强制转换。
4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法,子类方法有效
5、向上转型的作用,减少重复代码,父类为参数,调有时用子类作为参数,就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。
6、变量 instanceof 类名: 来判断该引用型变量所指向的对象是否属于该类或该类的子类。
实例程序:
this.属性:操作当前对象的属性
this.方法:调用当前对象的方法
2、封装对象的属性的时候,经常会使用this关键字。
实例程序:
●子类的构造方法都会首先去执行父类的构造方法,默认访问无参构造方法
因为:每一个构造方法的第一行都有一条默认的super();语句
作用:用于子类访问父类数据的初始化,只有执行了父类的无参构造方法,才能访问父类的数据
●注意:当父类没有无参构造方法时,子类的构造函数必须通过this和super关键字指定要访问的带参构造方法
●格式:super(...)括号中的内容由带参构造方法的参数类型决定
this()——前提是:必须已经有一个子类用super访问了父类构造方法
实例程序:
●属于所有类;第一次使用时被初始化。
●成员变量分布在data segment中;
●不需要new一个对象就可以访问。类名.成员变量就可以访问。
●用static声明的方法为静态方法,在调用时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。
●静态方法不再是针对某个对象的调用,所以不能访问非静态成员。
静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。
实例程序:
结果:
My name is mimi No.100
My name is pipi No.2000
●import:引入需要的
●最上层包的目录应在classpath中。
●java编译器把包对应于文件系统的目录管理,package语句中,用‘.’来指明包(目录)的层次,例如使用语句
package com.sxt;
该文件中所有的类位于.\com\sxt目录下。
●如果将一个类打包,则使用该类时,必须使用该类的全名(com.sxt.MyClass),java编译器才会找到该类。也可以使用import在文件的开头引用要使用到的类。
●jar-cvf text.jar *
例子:
![](http://img.blog.csdn.net/20150825083921469?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)
Person p = new Person();
System.out.println(p);
输出:自动调用toString(),栈中的地址:默认 类名@hashcode。
●为了得到地址所指向的对象的值,需要重写toString()。在eclipse中或idea中,可以自动添加此代码。
实例程序:
结果:
d:=I'm a cool dog!
在eclipse中或idea中,可以自动添加此代码。
实例程序:
结果:
false
false
false
true
●final修饰方法,该方法不能被重写。
●final修饰属性,该类的初始化属性必须有值或在构造方法中赋值(只能选其一)
●final修饰变量,该变量的值只能赋一次值,即变为常量。
实例程序:
结果:
TestFinal.java:15: 错误: 无法从最终T进行继承
class TT extends T {
^
1 个错误
●抽象类必须被继承。
●抽象方法必须被重写。
●抽象类不能被实例化。
●所有的成员变量都是public static final。
●所有的方法都是抽象的public的。
●子接口可以extens父接口,而不去实现父接口中的方法。
● 子类implements接口后,必须实现接口中的方法。
● 子类可以即extends父类,同时implements接口1,接口2
●接口和接口之间可以相互继承,
●类和接口之间只能implements。
●一个类可以实现多个接口。
●接口的本质:内存中,可以看见其对象的一部分方法。
实例程序:
class
●每个java类运行时都在JVM里表现为一个class对象,可通过类名.class,类型.getClass(),Class.forName("类名")等方法获取class对象。●常用的类:public StringgetName() ;当属性设为private
●在继承中注意:
public class Vehicle {...}
public class Car extends Vehicle {...}
public class SUV extends Car {...}
则Vehicle v = new SUV();是正确的。
new
实例化一个对象。默认调用参数相同的构造函数●内存中分四块:
堆:对象生成时(属性)。
栈:局部变量
Code segment:方法。
Data segment:静态常量
●一般和构造方法一起使用
reference
Dog dog = new Dog();其中dog就是对象的引用,在栈内存中存在,存放的是dog对象在堆内存中的地址。
constructor
●构造函数,和类同名,没有返回值。初始化成员变量,不加void,如果有父函数,先调用父函数构造函数,再调用子函数的构造函数。父类中须有无参构造函数。●拓展:单例模式等,构造函数的权限不同,用法不同。
实例程序:
class Worker { private String name; Worker(String name) { this.name = name; } public String getName(){ return name; } } public class TakeCarePet { public static void main(String[] args) { Worker w1 = new Worker("David"); System.out.println(w1.getName()); } }
输出结果:David
overload
重载,放在一个类中。1、在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int, float),但是不能为fun(int, int));
2、不能重载只有返回值不同的方法名。因为返回值区分不出来。
3、存在于父类和子类、同类中。
4、不能通过访问权限、返回类型、抛出的异常进行重载;
overwrite(override)
重写。如果子类对继承父类的方法不满意,可以重写,当调用方法时会优先调用子类的方法。特点:
1、方法名、参数、返回值相同。
2、子类方法不能缩小父类方法的访问权限。
3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;
5、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。
实例程序:
class Person { private String name; private int age; //overload Person(){ } Person(String name){ this.name = name; } Person(String name,int age){ this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public String getInfo() { return "name = " + name +". age = " + age ; } } class Student extends Person{ private String school; public void setSchool(String school) { this.school = school; } public String getSchool() { return school; } Student(String name,int age){ super(name,age); } //override public String getInfo() { return "name = " + getName() +". age = " + getAge() + ". school = "+ school; } } public class TextOverRide{ public static void main(String[] args) { Person p1 = new Person("Chirstina"); Person p2 = new Person("Sanpao",25); Student student = new Student("Monday",20); student.setSchool("ss"); System.out.println("p1的名字是:" + p1.getName()); System.out.println("p2的名字是:" + p2.getName()+ "。他的年龄是:" + p2.getAge()); System.out.println(student.getInfo()); } }
结果:
p1的名字是:Chirstina
p2的名字是:Sanpao。他的年龄是:25
name = Monday. age = 20. school = ss
polymophysm
在执行期间(非编译期间)判断所引用对象的实际类型,根据实际类型调用相应的方法。脑子里要有内存图,new 的是哪一个类就找相应的方法。条件:
1、 要用继承
2、 要用重写
3、 父类引用指向子类对象
实例程序:
abstract class Animal { private String name; Animal(String name) { this.name = name; } public abstract void enjoy(); } class Cat extends Animal { private String eyesColor; Cat(String n,String c) { super(n); eyesColor = c; } public void enjoy() { System.out.println("猫叫声......"); } } class Lady { private String name; private Animal pet; //多态的使用 Lady(String name,Animal pet) { this.name = name; this.pet = pet; } public void myPetEnjoy(){pet.enjoy();} } public class Test { public static void main(String args[]){ Cat c = new Cat("catname","blue"); Lady l1 = new Lady("l1",c); l1.myPetEnjoy(); } }
upcasting, downcasting
1、父类引用可以指向子类对象,子类引用不能指向父类对象。2、把子类对象直接赋给父类引用叫upcasting向上转型,向上转型不用强制转型。
如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting),要强制转型。
如father就是一个指向子类对象的父类引用,把father赋给子类引用son 即Son son =(Son)father;
其中father前面的(Son)必须添加,进行强制转换。
4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法,子类方法有效
5、向上转型的作用,减少重复代码,父类为参数,调有时用子类作为参数,就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。
6、变量 instanceof 类名: 来判断该引用型变量所指向的对象是否属于该类或该类的子类。
实例程序:
//向上转型向下转型 class Animal { public String name; Animal(String name) { this.name = name; } } class Cat extends Animal { public String eyesColor; Cat(String name,String eyesColor) { super(name); this.eyesColor = eyesColor; } } class Dog extends Animal { public String furColor; Dog(String name,String furColor) { super(name); this.furColor = furColor; } } public class Test { public static void main(String args[]) { Animal a = new Animal("a"); Cat c = new Cat("c","blue"); Dog d = new Dog("d","black"); System.out.println(a instanceof Animal); System.out.println(c instanceof Animal); System.out.println(d instanceof Animal); System.out.println(a instanceof Cat); //向下类型转换,注意三个的输出。子类对象的父类引用赋给子类引用 a = new Dog("littleRed","red"); System.out.println(a.name); //System.out.println(a.furColor);注意这句是错误的,a指向的对象中的父类属性。 Dog dog = (Dog)a; System.out.println(dog.furColor); Test test = new Test(); test.f(a); test.f(c); test.f(d); } //向下类型转换。输出对应的名字和相应的属性。 public void f(Animal a) { System.out.println("name:" + a.name); if(a instanceof Cat) { Cat cat = (Cat)a; System.out.println("eyesColor:" + cat.eyesColor); }else if(a instanceof Dog) { Dog dog = (Dog)a; System.out.println("furColor:" + dog.furColor); } } }
this
1、this代表当前对象this.属性:操作当前对象的属性
this.方法:调用当前对象的方法
2、封装对象的属性的时候,经常会使用this关键字。
实例程序:
class Animal { public String name; Animal(String name) { this.name = name; } }
super
●在子类中使用。●子类的构造方法都会首先去执行父类的构造方法,默认访问无参构造方法
因为:每一个构造方法的第一行都有一条默认的super();语句
作用:用于子类访问父类数据的初始化,只有执行了父类的无参构造方法,才能访问父类的数据
●注意:当父类没有无参构造方法时,子类的构造函数必须通过this和super关键字指定要访问的带参构造方法
●格式:super(...)括号中的内容由带参构造方法的参数类型决定
this()——前提是:必须已经有一个子类用super访问了父类构造方法
实例程序:
class Animal { public String name; Animal(String name) { this.name = name; } }
class Cat extends Animal {
public String eyesColor;
Cat(String name,String eyesColor) {
super(name);
this.eyesColor = eyesColor;
}
}
static
●在一段程序中,适当加入一个Static的值,使其运算后自加一,可以当作计数器。●属于所有类;第一次使用时被初始化。
●成员变量分布在data segment中;
●不需要new一个对象就可以访问。类名.成员变量就可以访问。
●用static声明的方法为静态方法,在调用时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。
●静态方法不再是针对某个对象的调用,所以不能访问非静态成员。
静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。
实例程序:
public class Cat { private static int sid = 0; private String name; int id; Cat(String name) { this.name = name; id = sid++; } public void info(){ System.out.println ("My name is "+name+" No."+id); } public static void main(String arg[]){ //赋值方式 Cat.sid = 100; Cat mimi = new Cat("mimi"); mimi.sid = 2000; Cat pipi = new Cat("pipi"); mimi.info(); pipi.info(); } }
结果:
My name is mimi No.100
My name is pipi No.2000
package, import
● package:解决类重名的问题●import:引入需要的
●最上层包的目录应在classpath中。
●java编译器把包对应于文件系统的目录管理,package语句中,用‘.’来指明包(目录)的层次,例如使用语句
package com.sxt;
该文件中所有的类位于.\com\sxt目录下。
●如果将一个类打包,则使用该类时,必须使用该类的全名(com.sxt.MyClass),java编译器才会找到该类。也可以使用import在文件的开头引用要使用到的类。
●jar-cvf text.jar *
例子:
import com.sxt.MyClass;import java.util.*;//引入java.util包中所有的类 MyClass myClass = new MyClass();//可以直接使用类名
public,default,private,protected
●对方若是private,只能看不能用。Object
一个类没有使用extends关键字,则默认继承Object类。toString
●实例程序:Person p = new Person();
System.out.println(p);
输出:自动调用toString(),栈中的地址:默认 类名@hashcode。
●为了得到地址所指向的对象的值,需要重写toString()。在eclipse中或idea中,可以自动添加此代码。
实例程序:
public class TestToString { public static void main(String[] args) { Dog d = new Dog(); System.out.println("d:=" + d); } } class Dog { public String toString() { return "I'm a cool dog!"; } }
结果:
d:=I'm a cool dog!
equals
类两个之间怎样算相等。x.equals(y)当x和y是同一个对象的应用时返回true否则返回false。在eclipse中或idea中,可以自动添加此代码。
实例程序:
public class TestEquals { public static void main(String[] args) { Cat c1 = new Cat(1, 2, 3); Cat c2 = new Cat(1, 2, 6); System.out.println(c1 == c2); System.out.println(c1.equals(c2)); String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); System.out.println(s1.equals(s2)); } } class Cat { int color; int height, weight; public Cat(int color, int height, int weight) { this.color = color; this.height = height; this.weight = weight; } public boolean equals(Object obj) { if(obj == null) return false; else { if(obj instanceof Cat) { Cat c = (Cat)obj; if(c.color == this.color && c.height == this.height && c.weight == this.weight) { return true; } } } return false; } }
结果:
false
false
false
true
final
●final修饰类,该类不可以被继承●final修饰方法,该方法不能被重写。
●final修饰属性,该类的初始化属性必须有值或在构造方法中赋值(只能选其一)
●final修饰变量,该变量的值只能赋一次值,即变为常量。
实例程序:
public class TestFinal { public static void main(String[] args) { T t = new T(); } } final class T { final int i = 8; public final void m() { } } class TT extends T { }
结果:
TestFinal.java:15: 错误: 无法从最终T进行继承
class TT extends T {
^
1 个错误
abstract
●含有抽象方法的类是抽象类。抽象方法只需声明,不需实现。●抽象类必须被继承。
●抽象方法必须被重写。
●抽象类不能被实例化。
interface
implements
●特殊的抽象类,●所有的成员变量都是public static final。
●所有的方法都是抽象的public的。
●子接口可以extens父接口,而不去实现父接口中的方法。
● 子类implements接口后,必须实现接口中的方法。
● 子类可以即extends父类,同时implements接口1,接口2
●接口和接口之间可以相互继承,
●类和接口之间只能implements。
●一个类可以实现多个接口。
●接口的本质:内存中,可以看见其对象的一部分方法。
实例程序:
interface Take { public static final String pet = "2"; public void Feed(); public void Play(); } class Worker implements Take { public void Feed() { System.out.println("吃菜"); } public void Play() { System.out.println("在家楼下玩"); } } class Farmer implements Take{ String pet = "1"; public void Feed() { System.out.println("吃米"); } public void Play() { System.out.println("在农场玩"); } } class Statecadres implements Take{ public void Feed() { System.out.println("吃肉"); } public void Play() { System.out.println("在家玩"); } } public class TakeCarePet { public static void main(String[] args) { Take p1 = new Worker(); Take p2 = new Farmer(); Take p3 = new Statecadres(); p1.Feed();p1.Play(); p2.Feed();p2.Play(); p3.Feed();p3.Play(); System.out.println(p2.pet); } }
相关文章推荐
- eclipse工具使用技巧&关联Android源码
- eclipse导入一个项目之后没有JRE System Library怎么办?
- SSi框架整合
- 直接topbar奔溃,出现 at java.lang.reflect.Constructor.constructNative(Native Method)
- maven在eclipse建立工程,运行出现Server IPC version 9 cannot communicate with client version 4错误
- 玩转Eclipse — 自动代码生成的Java Code Template
- java中实现四则运算代码
- java IO 学习笔记之FIle
- Java开发中学用eclipse code templates
- JSON 转javabean 利器
- java-内部类说明
- struts2学习笔记——03
- 《Java实战开发经典》第五章5.1
- java获得当前时间戳
- Myeclipse 安装 gradle 插件以及基本使用
- Spring MVC XmlViewResolver example
- Spring MVC InternalResourceViewResolver example
- 去哪网实习总结:windows下配置JavaWeb环境、开发helloworld、发布系统(附截图,绝对详细)(JavaWeb)
- 【Java并发编程实战】-----“J.U.C”:ReentrantLock之三unlock方法分析
- Eclipse优化工具Optimizer for Eclipse