1：继承
Java的一大特点：
跨平台。
代码的三个特点：
继承，多态、封装。
1.1、Java对象的组成部分
package cn.domain;
public class Person {
private String name;//这成员变量>属性
private Integer age;
private String skinColor;
public void say() { //方法对外公开提供的服务
System.err.println("Hello..");
}
}
1.2、对象之关系
组合：
//计算机类
class Computer{ //组合- DIY
private Cpu cpu;
private Screen screen;
}
class Cpu{
}
class Screen{
}
依赖：
//计算机类
class Computer{ //组合- DIY
private Cpu cpu;
private Screen screen;
public void run(){
//如果一个类，在方法里，使用了另一个类，此时就是叫：Computer依赖于USB这个类。
USB usb = new USB();
}
}
2：继承
在Java里面一个类继承另一个类用的是 extends 关键字：
从父类中继承的是public、protected的方法与属性：
class Father{
public String name = "Jack";
protected String addr = "济南";
String hobby = "Football";
private String tel = "12899";
public void say(){
System.err.println("hi im father..");
}
protected void hi(){
System.err.println("hi im father.222.");
}
}
class Child extends Father{
}
继承 | public | protected | 默认 |
同一个包中 | 继承 | 继承 | 继承 |
不同的的包中 | 继承 | 继承 | 不能继承 |
//如果子类拥有相同 的父类的成员属性与方法则在调用时先调用子类的
class Child extends Father{
public String name = "Mike";
protected String addr = "山东";
String hobby = "MATV";
public void say(){
System.err.println("hi im child..");
}
protected void hi(){
System.err.println("hi im child.222.");
}
}
3：重写 Overried
子类的方法与父类的方法重名：
要求：
1：子类与父类方法重名。
2：了类的方法与父类的方法的参数类型，顺序，个数 完全一样。
3：子类权限修饰符号，不缩小，但可以放大。
4：多态
1：类型转换
public class Demo03 {
public void test1(){
//自己的类型=自己的对象
Dog dog = new Dog();
//让dog对象赋值给Animal
Animal a1 = dog;//可以
//让大类型赋值给小类型,在编译时a1是Animal类型 dog2是Dog小类型，但a1本质就是dog
Dog dog2 = (Dog)a1;
System.err.println("Over..");
}
}
class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}
--
public void test1() {
//父类型的变量= 子类型的实例
Animal a1 = new Dog();
Dog dog2 = (Dog)a1;
System.err.println("over..");
//a2本质是一个动物
Animal a2 = new Animal();
//此时会出现运行时错误 - 因为a2本质 是指向的Animal的实例
Dog dog3 = (Dog) a2;
System.err.println("如果运行出错，则此行代码不显示");
}
2：动态调用
是指在运行时动态的调用子类的非静态的方法。
package cn.demo;
import javax.sound.midi.SysexMessage;
import org.junit.Test;
public class Demo03 {
public void test1() {
//类型 变量 对象
Animal a = new Dog();
a.say();//实例方法【非静态的方法】与对象绑定-动态绑定
System.err.println(a.name);//Jack - 成员变量 与类型绑定 - 静态绑定
a.hi();//静态的方法与变量的类型绑定
}
}
class Animal {
public String name = "Jack";
public void say(){
System.err.println("不知道是什么动物");
}
public static void hi(){
System.err.println("hi11111......");
}
}
class Dog extends Animal {
public String name = "Mary";//成员变量不会覆盖
@Override
public void say() { //重写覆盖 - 只有实例方法才会有多态的概念
System.err.println("wwwwww......");
}
public static void hi(){
System.err.println("hi2..............");
}
}
5：继承与Object类
在Java代码中，java.lang.Object是所有类的最高父类。所有类默认都是这个类的子类。
可以通过
Instanceof – 是不是某种类型
public class Demo03 {
public void test1() {
Dog xy = new Dog();
System.err.println("xy是DOg类型的吗："+(xy instanceof Dog));//true
System.err.println("xy是animal类型的吗："+(xy instanceof Animal));//true
System.err.println("xy是东西："+(xy instanceof Object));//true
//在比较时，instanceof比较的对象必须要有继承的关系，否则出错
System.err.println("xy是cat吗："+(xy instanceof Cat));
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat{
}
6：从Obejct里面都继承的什么方法
所有类，都拥有toString方法，它们是Object类里面继承的。
如果子类没有重写toString方法则调用父类。
默认的ObObject类里面的toString显示的是：
public String toString() {
类的名称 @ 转成16进制 内部地址值
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
对于toString:
1:所有类都拥有这个方法，继承的。
2：如果将一个类与字符串串联，默认就调用这个方法。或是输出某个对象默认也调用个方法
7：equals
比较两个对象的内部内容是否一样
=-= 是比较两个对象的内存地址是否一样。
public class Demo03 {
@Test
public void test1() {
String str1 = new String("Hello");
String str2 = new String("Hello");
System.err.println("内存地址是否一样:"+(str1==str2));//false
System.err.println("里面的内容是否一样："+str1.equals(str2));//true
}
}
开发一个自己的对象：
在Object类里面源代码是：
*/
public boolean equals(Object obj) {
return (this == obj); - 内部默认依然是比较内存地址
}
s1.equals(s2);
如何才可以比较里面的内容：
package cn.demo;
import org.junit.Test;
public class Demo04 {
@Test
public void test1() {
Student s1 = new Student("Jack",23);
Student s2 = new Student("Jack",33);//作业：当age,name完全 一样才是true否则就false
System.err.println("两个学生的内存是否一样:" + (s1 == s2));// false
boolean boo = s1.equals(s2);
System.err.println("两个学生的内容一样:" + boo);// true
Dog dog = new Dog();
boo = s1.equals(dog);
System.err.println(boo);// true | false
}
}
class Student {
private String name;
private Integer age;
public Student(String name,Integer age) {
this.name = name;
this.age=age;
}
@Override
public boolean equals(Object obj) {
// 1:比较两个对象地址是否一样，如果地址一样，则内容一定一样
if (this == obj) {
return true;
} else { // 再比较里面的内容
if (obj instanceof Student) {
Student s2 = (Student) obj;
if (this.name.equals(s2.name)) {
return true;
} else {
return false;
}
}else{
return false;
}
}
}
}
class Dog {
}