Java面向对象- -day3

重写（override

子类从父类继承的方法，如果不能满足子类的需要，可以重写父类的方法。即方法名和参数列表和
父类保持完全一致，方法的实现不同。
子类重写父类的方法之后，子类对象优先调用自己的方法。
子类重写父类的方法的时候，可以在重写的方法中，使用super关键字调用到父类的方法。
子类重写了父类的方法，那么就调用子类自己的方法，否则就调用父类的方法。

public class Art {
    public void print(){
        System.out.println("艺术家");
    }
}
class HuaJia extends Art{
    @Override  //**注解，（@.类型名），对类，方法。属性进行特殊的注释
                //@Override--重写，放在方法前，表示必须重写父类的方法
    public void print() {
        //super.print(); //--调用父类方法，根据需要删除该行代码
        System.out.println("画家");
    }
}
class ShuFa extends Art{
    @Override
    public void print() {
        System.out.println("书法家");
    }
}
class DiaoShu extends Art {
    @Override
    public void print() {
        System.out.println("雕塑家");
    }
}
class GangQin extends Art{

}
class TestArt{
    public static void main(String[] args) {
        //**子类重写父类的方法，那么子类调用自己的方法，否则调用父类的方法
        Art art1=new DiaoShu();
        art1.print();//调用子类的方法
        Art art2=new ShuFa();
        art2.print();//调用子类的方法
        Art art3=new HuaJia();
        art3.print();//调用子类的方法
        Art art4=new GangQin();
        art4.print();  //调用父类的方法
    }
}

 package关键字

 定义类的时候需要指定类的名称。但是如果仅仅将类名作为类的唯一标志，则会出现命名冲突的问
题。
在java中，是用package 来解决命名冲突的问题。因此定义类的时候，一般需要先给类指定一个包
名。
类的真实名字是： 包名 + 类名。
包名可以有层次结构，一个类可以有多层包名。

 

 指定包名的时候建议使用： 公司域名反写 + 项目名 + 项目模块名 + mvc模式分层

import关键字

如果要在程序中，使用某个类，可以用该类的全名，这样比较复杂。
java.util.Date date = new java.util.Date();
一般使用import 语句导入这个类，然后使用该类。

访问控制符public 和 private

private修饰的成员变量和方法仅仅只能在本类中调用，因此private修饰的内容是对内实现数据的
封装，如果“公开”会增加维护的成本。
public修饰的成员变量和方法可以在任何地方调用，因此public修饰的内容是对外可以被调用的功
能。
在定义类的时候，一般采用成员变量私有化，方法公开的原则。
5.2访问控制符protected 和默认访问控制
用protected修饰的成员变量和方法可以被子类及同一个包中的类使用。
默认访问控制即不书写任何访问控制符，默认访问控制的成员变量和方法可以被同一个包中的类调
用。

对于class的访问权限符只能使用public和默认（default)
访问控制符权限对比

 同一个类中

package day2;
// 访问权限的设置
public class Demo1 {
  private  String name;
  String sex;
  protected String hobby; // 爱好
  public String keyWord;// 关键字
  // 同一个类中，都能访问
  void  print(){
    System.out.println(name); //
    System.out.println(sex); //
    System.out.println(hobby);
    System.out.println(keyWord);
 }
}

 同包中

class TestA{
  public static void main(String[] args) {
    Demo1 d = new Demo1();
   // d.name = ""; // 私有变量，只能再自己的类中被访问到。
    d.sex = "男"; // 同包中可以访问： 默认修饰， protected ，public
    d.hobby = "看书";
    d.keyWord = "自信";
 }
}

不同包中，有继承

public class SubDemo2 extends Demo1 {
  void  print(){
   // System.out.println(name); // 私有变量，只能再自己的类中被访问到。
   // System.out.println(sex); // 不同包中访问不了。
    System.out.println(hobby); // 不同包中，有继承关系
    System.out.println(keyWord); // 不同包中，有继承关系
 }
}

不同包中，不同类中，没有继承

 public static void main(String[] args) {
    Demo1 demo1 = new Demo1();
   // System.out.println(demo1.name); // 不同包的其他类，不能使用。
    //System.out.println(demo1.sex); // 不同包的其他类，不能使用。
    //System.out.println(demo1.hobby); // 不同包的其他类，不能使用。
    System.out.println(demo1.keyWord); // 不同包的其他类中。
 }

 方法的定义—return关键字

如果方法定义中有返回值类型的设置，需要使用return返回一个相同类型的数据

在方法中，可以使用return关键字，结束方法的运行

static关键字的使用

用static修饰的成员变量不属于对象的数据结构
static修饰的变量属于类的变量，通常可以通过类名来引用static成员
static成员变量和类的信息一起存储在方法区，而不是在堆内存中
一个类的静态成员变量只有一份，而非静态成员对象有多份，即每个对象都有自己的非静态成员变
量。

public class Cat {
  // 猫的特征(描述对象)
  String name;
  String sex;
  int age;
  // 统计出猫（对象）的个数
  static int count ;
  public Cat(){
    count ++;
 }
  public Cat(String name , String sex , int age){
    this.name =name;
    this.sex = sex;
    this.age = age;
    count ++; // 每创建一次对象， 猫的数量就加1.
 }
}
class  TestCat{
  public static void main(String[] args) {
    // count是Cat类中的静态变量，可以通过类名直接访问静态变量。
    System.out.println(Cat.count); //0
    Cat cat = new Cat();
    cat.age = 3;
    cat.sex = "公猫";
    cat.name = "tom";
    // cat.count++; // 增加了一只猫
   // Cat.count ++;
   // System.out.println(cat.count); //1

static关键字—修饰方法
类中的方法，通常都会涉及到堆具体对象的操作，这些方法在调用时，需要隐式的传递对象的引
用。

void print(){
System.out.println(this.x + "," + this.y);
}

static修饰的方法则不需要针对对象进行操作，其运行结构仅仅与输入的参数有关系。调用时候直
接通过类名引用。
Math.sqrt(100)
static修饰的方法是属于类的方法，通常用于提供工厂方法，或者工具方法。
static修饰的方法，调用的时候没有具体的对象，因此static修饰的方法不能调用非静态成员变量和
成员方法。
 

 静态方法中，无法调用非静态发成员变量和非静态的成员方法。
//  *** 非静态的成员变量和非静态的成员方法，属于对象的， 只能通过对象调用。
//  *** 静态的成员变量和成员方法，属于类的，可以通过类名直接调用(也可以通过对象的引用进行
调用)。
public class Dog {
  String name;
  String sex;
  static  int count = 5;
  // 输出狗的数量，以及当前这只狗的属性
  public void  print(){ // 非静态方法： 属于对象，通过对象进行调用。
    System.out.println("一共：" + count);
    System.out.println("名字：" + this.name +"," + ",性别：" + this.sex );
 }
  //增加狗的数量: 只要new了一个对象，就调用add方法，修改狗的总数
  public static void add(){
    count ++;
    /*
    System.out.println("当前增加的狗的名字：" + this.name); // 静态方法： 属于
类 ，name是非静态的成员变量，属于对象的。
    this.print(); // print()是非静态方法，属于对象，通过对象来调用。
    */
 }
  public static void main(String[] args) {
    count ++;
    add();
    // name = "xx";// 非静态的，不能直接在静态的方法中使用。
    Dog dog = new Dog();
4.final关键字
修饰类
final关键字修饰的类不可以被继承
对于一些类，设置了final修饰，可以避免滥用继承造成的危害
修饰方法
final关键字修饰的方法可以不被重写
防止子类在定义自己的方法的时候，不经意被重写。
    dog.name = "tom";
    dog.sex ="公";
    dog.print();
 }
}
public class FinalDemo {
}
// final修饰的类，不能被继承。
// *** jdk中的很多类，都是final修饰的。
final  class A{
}
//class B extends A{
//
//}
class  Shape{
  // final double PI = 3.14; // final修饰的变量，就不可以修改数据值。
  static  final double PI = 3.14; // static + final修饰成员变量， 本质定义的是
常量。
  /* 常量：为了方便程序中使用常量，常量定义为static + final修饰， 常量都用大写字母表
示（常量是多个单词，使用_分割）
  //Math.PI
  //Integer.MAX_VALUE
  // Integer.MIN_VALUE
  */
  int x;
  int y;
  // final修饰的方法，不允许被子类重写。
  public final void  print(){
    System.out.println("("+x+","+y+")");
 }
}
/*
class SanJiao extends Shape{
  // 父类的方法是final修饰的，子类不能重写。
  public void print(){
    System.out.println("***"+x+","+y+"***");
  }
}
class SanJiao1 extends Shape{
  public void print(){
修饰变量
final修饰成员变量，意为不可以改变。该成员变量需要在初始化的时候赋值，对象一旦创
建，即该值不可以改变。
5.对象数组
所谓对象数组，对象数组的元素不是基本类型，而是引用类型。
    System.out.println("*{*"+x+","+y+"*}*");
  }
}*/
public class FinalDemo1 {
  // 创建数组，长度固定为5.
  static  final int LENGTH = 5;
  // 1 ~100的素数
  static  final int MAX = 100;
  // 连接mysql数据库
  static  final int PORT =  4408; // 4408
  public static void main(String[] args) {
    int[] a = new int[FinalDemo1.LENGTH] ;
    for(int i = 0 ; i < FinalDemo1.LENGTH ; i++){
      a[i] = i;
   }
    for(int i= 2; i < FinalDemo1.MAX ; i++){
   }
    // 使用。PORT
    System.out.println(FinalDemo1.PORT);
 }
}