Java面向对象（下）

最新推荐文章于 2021-08-18 13:03:34 发布

技术蜗牛-阿春

最新推荐文章于 2021-08-18 13:03:34 发布

阅读量582

点赞数

分类专栏： ➤Java 文章标签： jar包对象转型接口 java抽象类动态绑定

本文链接：https://blog.csdn.net/whc888666/article/details/104286286

版权

➤Java 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

包

定义：为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java引入包（package）机制，提供类的多重命名空间。

package语句作为java源文件的第一条语句，指明该文件的中定义的类所在的包，若缺省该语句，则指定为无名包。
java编译器把包对应于文件系统的目录管理，package语句中，用“.”来指明包目录的层次。
如：package com.sxt;则该文件中所有的类位于.\com\sxt目录下
如果想将一个类放入包中，在这个源文件第一句话写package
必须保证该类的class文件位于正确的目录下
必须将class文件的最上层包的父目录位于classpath下
执行一个类的时候也要写全包名

实例

package lee;
public class Hello{
	public static void main(String [] args){
		System.out.println("Hello World!");
	}
}

package lee;
import lee.sub.Apple;
public class HelloTest{
	public static void main(String [] args){
		Hello hello =new Hello();
		Apple a = new Apple();
	}
}

package lee.sub;
public class Apple{}

编译语句：javac -d . 类名.java

这样的好处是这个类里引入的包，直接就可以将先关的.class 文件生成到相应的文件夹下。

Java常用包

Java.lang:这个包下包含了java语言的核心类，如string、Math、System和Thread类，使用这个包下面的类无需使用import语句导入，系统会自动导入这个包下的所有类。

访问控制

java权限修饰符public、protected、private置于类的成员定义前，用来限制其他对象对该类对象成员的访问权限

对于class的权限修饰只可以用public（类可以在任意地方被访问）和default（类只可以被同一个包内部的类访问）

类的继承与权限访问

java中使用extends关键字实现类的继承机制
通过继承，子类自动拥有了基类superclass的所有成员（成员变量和方法）
java只支持单继承，不允许多继承

实例代码：

class Person{
	private String name;
	private int age;
	public void setName(String name){
		this.name = name;
	}
	
	public void setAge(int age ){
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
}

class Student extends Person{
	private String school;
	public String getSchool(){
		return school;
	}
	
	public void setSchool(String school){
		this.school = school;
	}
}

public class TestPerson{
	public static void main(String args[]){
		Student student = new Student();
		student.setName("Jason");
		student.setAge(28);
		student.setSchool("清华大学");
		System.out.println(student.getName());
		System.out.println(student.getAge());
		System.out.println(student.getSchool());
	}
}

输出结果：

继承中的构造方法

子类的构造过程中必须调用其基类的构造方法；
子类可以在自己的构造方法中使用super调用基类的构造方法；
如果调用super必须写在子类构造方法的第一行；
如果子类的构造方法中没有显示的调用基类的构造方法，则系统默认调用基类无参数的构造方法；
如果子类构造方法中既没有显示的调用基类的构造方法，而基类中又没有无参数的构造方法，则编译出错。

实例代码：

class SuperClass{
	private int n;
	SuperClass(){
		System.out.println("SuperClass()");
	}
	
	SuperClass(int n){
		System.out.println("SuperClass(" + n +")");
		this.n = n;
	}
}

class SubClass extends SuperClass{
	private int n;
	SubClass(int n){
		System.out.println("SubClass(" + n +")");
		this.n = n;
	}
	
	SubClass(){
		super(300);
		System.out.println("SubClass()");
	}
}

public class TestSuperSub{
	public static void main(String arg[]){
		SubClass sc1 = new SubClass();
		SubClass sc2 = new SubClass(400);
	}
}

输出结果：

方法的重写

在子类中可以根据需要对从基类中继承来的方法进行重写；
重写方法必须和被重写方法具有相同的方法名称、参数列表和返回类型；
重写方法不能使用比被重写方法更加严格的访问权限。

实例代码：

class Person{
	public String name;
	public int age;
	public void setName(String name){
		this.name = name;
	}
	
	public void setAge(int age ){
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
	
	public String getInfo(){
		return "My Name: " + name + "\n" + "Age: " + age;
	}
}

class Student extends Person{
	private String school;
	public String getSchool(){
		return school;
	}
	
	public void setSchool(String school){
		this.school = school;
	}
	
	public String getInfo(){
		return "My name: " + name + "\n" + "Age: " + age + "\n" + "My school: " + school;
	}
}

public class TestPerson{
	public static void main(String args[]){
		Student student = new Student();
		Person person = new Person ();
		person.setName("小明");
		person.setAge(29);
		student.setName("Jason");
		student.setAge(28);
		student.setSchool("清华大学");
		System.out.println(person.getInfo());
		System.out.println(student.getInfo());
	}
}

输出结果：

Object类

Object类是所有java类的根基类；
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

toString方法

Object类中定义有public String toString（）方法，其返回值是String类型，描述当前对象的有关信息；
在进行String与其他类型数据的连接操作时，如：System.out.println();将自动调用该对象的toString（）方法；
可以根据需要在用户自定义类型中重写toString（）方法。

实例代码：

public class TestToString{
	public static void main(String [] args){
		Dog d = new Dog();
		System.out.println("d:=" + d);
	}
}
class Dog{
	public String toString(){
		return "Iam a hot Dog!";
	}
}

输出结果：

equals方法

Object类中定义有
Public boolean equals(Object obj)方法，提供定义对象是否“相等”的逻辑；
Object的equals方法定义为：X.equals(y)当x和y是同一个对象的应用时返回true否则返回false；
jdk提供了一些类，如String、Date等，重写了Object的equals方法，调用这些类的equals方法，X.equals(y),当x和y所引用的对象是同一类对象且属性内容相等时，返回true否则返回false；
可以根据需要在用户自定义类型中重写equals方法。

实例代码：

public class TestEquals{
	public static void main(String [] args){
		Cat c1 = new Cat(1,2,3);
		Cat c2 = new Cat(1,2,5);
		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(c1.equals(c2));
	}
}

class Cat{
	int color;
	int height;
	int 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;
    }
}

输出结果：

对象转型（casting）

一个基类的引用类型变量可以“指定”其子类的对象；
一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）；
可以使用引用变量instanceof类名来判断该引用类型变量所“指向”的对象是否属于该类或该类的子类；
子类的对象可以当做基类的对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）。

动态绑定（多态）

动态绑定是指在执行期间而非编译期间判断所引用对象的实际类型，根据其实际的类型调用相应的方法

三个必要条件：

要有继承；
要有重写；
父类引用指向子类对象；

实例代码：

class Animal{
	private String name;
	Animal(String name){
		this.name = name;
	}
	
	public void enjoy(){
		System.out.println("叫声...");
	}
}

class Cat extends Animal{
	private String eyesColor;
	Cat(String n, String  c){
		super(n);
		eyesColor = c;
	}
	
	public void enjoy(){
		System.out.println("猫叫声...");
	}
}

class Dog extends Animal{
	private String furColor;
	Dog(String n, String  c){
		super(n);
		furColor = 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 TestPlo{
	public static void main(String args[]){
		Cat c = new Cat("Catname","blue");
		Dog d = new Dog("Dogname","black");
		Lady l1 = new Lady("11",c);
		Lady l2 = new Lady("12",d);
		l1.myPetEnjoy();
		l2.myPetEnjoy();
	}
}

输出结果：