马士兵Java视频第三章总结

最新推荐文章于 2022-08-31 11:20:47 发布

暖暖_Christine

最新推荐文章于 2022-08-31 11:20:47 发布

阅读量936

点赞数

分类专栏： JAVA开发

本文链接：https://blog.csdn.net/yolanda997/article/details/47955021

版权

JAVA开发专栏收录该内容

8 篇文章 0 订阅

订阅专栏

写出以下关键词的含义、用法、并附上经过调试无误的实例。

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);
	}
}

暖暖_Christine

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
马士兵Java视频第三章总结

写出以下关键词的含义、用法、并附上经过调试无误的实例。class●每个java类运行时都在JVM里表现为一个class对象，可通过类名.class,类型.getClass(),Class.forName("类名")等方法获取class对象。●常用的类：public StringgetName() ；当属性设为privatenew实例化一个对象。默认调用参数相同的构造函数●内
复制链接

扫一扫