达内培训面向对象第四天笔记

回顾:
1.对象内存管理
2.继承
3.super
4.向上造型


问: 构造方法可以继承吗?----不可以
父类的构造方法不是被继承的，而是被调用的
class Aoo{
  int a;
  Aoo(){
  }
  void show(){}
}
class Boo extends Aoo{
  int b;
  Boo(int b){
     super();
     this.b = b;
  }
  void say(){}
}


Boo o = new Boo();  //编译错误














笔记:
1.方法的重写:覆盖，改
2.重写(override)与重载(overload)的区别:----常见面试题
   1)重写:父子类中，方法名相同，参数列表相同，方法体不同
             运行期绑定，根据对象绑定方法(看对象)
   2)重载:方法名相同，参数列表不同
             编译期绑定，根据参数的类型绑定方法(看类型)
2.package:
   1)作用:避免命名冲突
   2)可以有层次结构，包名建议所有字母都小写
   3)同包中的类可以直接访问
      不同包中的类:
         3.1)先import声明/引入类，直接访问----建议
         3.2)完全限定名: 包名.类名-------不建议
   import:
   1)作用:声明类、引入类
   2)语法:  import  包名.类名;
3.访问控制修饰符:
   1)public:公共的，任何地方都可以
   2)protected:受保护的，本类、子类、同包类
   3)默认的:什么也不写，本类、同包类
   4)private:私有的，本类
   类只能用public或默认的来修饰
   类中的成员可以用如上4个来修饰
4.static:静态的
   1)修饰成员变量-----静态变量
      1.1)属于类的，而不属于对象
      1.2)和类的信息一起存储在方法区中，只有一份
      1.3)常常通过类名.来访问
      1.4)何时用:所有对象的值都一样时
   2)修饰方法--------静态方法
      2.1)没有隐式的this的传递
      2.2)静态方法中不能直接访问实例成员(实例变量、方法)
            可以直接访问静态成员(静态成员不需要对象来访问，类名.)
      2.3)常常通过类名.来访问
      2.4)何时用:方法的操作与对象无关，而仅与参数相关
   3)修饰块---------静态块
      3.1)在类被加载期间执行
      　　因为类只被加载一次，所以静态块也只执行一次
      3.2)何时用:加载静态资源(图片、音频、视频......)
5.final:最终的
   1)修饰变量:变量不可被修改
   2)修饰方法:方法不可被重写
   3)修饰类:类不可被继承




任务:
1.演示方法重写的一大(访问权限)和一小(返回值类型)


作业:
1.理论题
2.操作题
3.打开一个记事本:
     访问修饰符小代码
     static小代码
     final小代码








课本86页最后一个PPT(static final常量)------自学














FinalDemo


CS游戏-------地图
地图这个数据，所有对象都一样，所以做成静态变量(静态资源)
静态块，给静态资源赋值












静态方法:方法的操作仅与参数相关，与对象无关
double a = Math.random();
double b = Math.sqrt(25);
int[] a1 = Arrays.copyOf(a,6);
Arrays.sort(arr);


static void sort(int[] arr){
   仅仅是对arr进行升序
}












Math m1 = new Math();
m1.sqrt(25);-----5


Math m2 = new Math();
m2.sqrt(25);-----5


Math m3 = new Math();
m3.sqrt(25);-----5




//方法中访问成员变量前面默认有个this.
普通方法默认都有个this传递过来
静态方法没有隐式的this传递


0:this代表当前对象
1.实例成员必须通过对象.来访问
2.静态方法没有隐式的this传递
   没有this，意味着没有对象
   没有对象，意味着不能直接访问实例成员


Cell c1 = new Cell(2,5);
c1.drop();


Cell c2 = new Cell(3,6);
c2.drop();


drop()方法的操作与对象相关，所以不能static的
















class Cell{
   int row;
   int col;
   static int a;
   void drop(){   //有一个默认的this传递过来了
   }
   void moveLeft(){
   }
   void moveRight(){
   }
   String getCellInfo(){
   }
   
   static void show(){   //没有this传递的
      row++;  //编译错误(row只能通过对象.来访问，需要对象的)
      a++;      //正确的(a可以由类名.来访问，不需要对象)
   }
}
Cell c1 = new Cell();
c1.drop();






















class Cus{
   String cardId;
   String cardPwd;
   double balance;
   static double peri;
}
Cus.peri = "0.65";


















class Student{
   String name;
   int age;
   String address;
   static String className;
}
Student.className = "JSD1503";


Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";


Student ls = new Student();
ls.name = "lisi";
ls.age = 26;
ls.address = "山东";


















StaticDemo








成员变量分两种:
1.实例变量: 不由static修饰
2.静态变量: 由static修饰


class Aoo{
    int a;    //实例变量
    static int b;  //静态变量
}


Aoo.b = 1;


Aoo o = new Aoo();
o.a = 1;


方法区: 类(.class)，方法，静态变量(1份)
Aoo o1 = new Aoo();












语法规定:类只能用public和默认的
              类中的成员可以用4种访问修饰


内部类-----类中套类
class Aoo{
   class Boo{  //内部类
   }
}








oo.day04.vis






第一次----不对
第二次----不对


问:我的密码是多少?


pwd密码
public boolean checkPwd(String pwd){
   .....一堆验证
   return true/false;
}


超市购物-------250元


不光光要保护数据，常常还需要去保护一个功能的实现过程






package p1;
class Aoo{
}


package p2;
class Aoo{
}


package p3;
import p1.Aoo;
import p2.Aoo;
class Test{
   void show(){
      p1.Aoo o1 = new p1.Aoo();
      p2.Aoo o2 = new p2.Aoo();
   }
}












package day02;
import java.util.Scanner;
import java.util.Arrays;
public class Test{
   main(){
      Scanner scan = new Scanner(System.in);
      int num = scan.nextInt();
      
      Arrays.sort(arr);
      
   }
}














民生银行-----上亿的钱java做一套软件


A公司-----A模块
B公司-----B模块
C公司-----C模块


假设A公司项目
   abc------Aoo
假设B公司项目
   abc------Aoo


包名的命名建议:
   域名反写       .  项目名称               . 模块名称
   com.tarena   .   studentmanager   . teachermana
   com.tarena  .    studentmanager   . studentmana
   公司不冲突      项目不冲突              模块不冲突
   
同包中的类，可以直接访问  
不同包中的类，不可以直接访问:
1.import引入类----建议
2.完全限定名----太长了，不建议
 
package p1;
class Aoo{
}
class Boo{
   void show(){
      Aoo o = new Aoo();
   }
}


package p2;
import p1.Aoo;  //声明Aoo类、引用Aoo类
class Coo{
   void show(){
      Aoo o = new Aoo();  //完全限定名
   }
}
























重载看类型，重写看对象
void a(Coo o){
   o.show();  //调Doo的
}
void a(Doo o){
   o.show();
}


Coo o = new Doo(); //向上造型
a(o); ------ 第一个






1000个类------不能同名
java建议，将类都放在包中
  同一包中的类，不能同名


















.java----.class
编译期时，还没有对象的










OverrideOverloadDemo






Student zs = new Student();
zs.name = "zhangsan";
zs.age = 25;
zs.address = "廊坊";
zs.className = "JSD1503";
zs.sayHi();------姓名，年龄，地址


Teacher wkj = new Teacher();
wkj.name = "wangkejing";
wkj.age = 26;
wkj.address = "佳木斯";
wkj.salary = 5000;
wkj.sayHi();------姓名，年龄，地址


重写的方法被调用时，看对象


Person p1 = new Person();
p1.sayHi();   //----Person的


Student stu = new Student();
stu.sayHi();  //----Student的


Person p2 = new Student();  //向上造型
p2.sayHi();  //----Student的




class Person{
   String name;
   int age;
   String address;
   void say(){
      System.out.println(name+","+age+","+address);
   }
}
class Student extends Person{
   String className;
   void say(){
      System.out.println(name+","+age+","+address+","+className);
   }
}
class Teacher extends Person{
   double salary;
   void say(){
      System.out.println(name+","+age+","+address+","+salary);
   }
}
class Doctor extends Person{
   String level;
}