Chinaunix首页 | 论坛 | 博客
  • 博客访问: 234187
  • 博文数量: 113
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 1044
  • 用 户 组: 普通用户
  • 注册时间: 2015-02-15 16:09
文章分类

全部博文(113)

文章存档

2016年(5)

2015年(108)

我的朋友

分类: Java

2015-10-26 21:02:55

2./*final关键字用法
掌握final关键字的使用要求
掌握全局常量的声明
使用final声明的类不能有子类;
使用final声明的方法不能被子类所覆盖;
使用final声明的变量即成为常量,常量不可以修改
如果一个程序中使用public static final关键字联合声明的变量称为全局常量:
public static final String INFO = "LXH" ;
在使用final声明变量时,要求全部的字母大写,如INFO,这点在开发中是非常重要的。 */
class Person{
final int age=100;
public static final String INFO="LXH" ;
}
public class test1{
public static void main(String args[]){

Person p1=new Person();
System.out.println(p1.age);
System.out.println(p1.INFO);
}
}
3.instanceof关键字

点击(此处)折叠或打开

  1. /*instanceof 关键字
  2. 对象 instanceof 类 ? 返回boolean类型
  3. 如果x属于类A的子类B,x instanceof A值也为true。
  4. */
  5. class A {
  6.     int a=100;
  7.     public void fun1(){
  8.         System.out.println(a);
  9.     }
  10. }
  11. class B extends A{
  12.     public void fun2(){
  13.         System.out.println("abc");
  14.     }
  15. }
  16. class test1{
  17.     public static void main(String args[]){
  18.         B b=new B();
  19.         A a=b;
  20.         boolean x=a instanceof B;
  21.         boolean y=a instanceof A;
  22.         System.out.println(x+","+y);
  23.     }
  24. }


点击(此处)折叠或打开

  1. /*对象的多态性
  2. 对象的向上转型(重点)
  3. Student s=new Student();
  4.           Person p=s;
  5. 或Person p=new Student();*/
  6. /*父类*/
  7. class A{
  8.     public void fun1(){
  9.         System.out.println("A-->");
  10.     }
  11.     public void fun2(){
  12.         this.fun1();
  13.     }
  14. };
  15. /*子类*/
  16. class B extends A{
  17.     public void fun1(){
  18.         System.out.println("B-->public void fun1---");
  19.     }
  20.     public void fun3(){
  21.         System.out.println("B---phblic void fun3");
  22.     }
  23. };
  24. public class test1{
  25.     public static void main(String [] args){
  26.         B b=new B();
  27.         A a=b;
  28.         a.fun1();
  29.     }
  30. }



点击(此处)折叠或打开

  1. /* 子类对象实例化过程
  2. 使用super可以从子类中调用父类中的构造方法、普通方法、属性。
  3.  */
  4. class Person {            // 定义父类Person
  5.     private String name;        // 定义name属性
  6.     private int age;        // 定义age属性
  7.     public Person(String name,int age){// 通过构造方法设置name和age
  8.         this.setName(name);    // 设置name属性内容
  9.         this.setAge(age);        // 设置age属性内容
  10.     }
  11.     public void setName(String name){
  12.         this.name=name;
  13.     }
  14.     public String getName(){
  15.         return this.name;
  16.     }
  17.     public void setAge(int age){
  18.         this.age=age;
  19.     }
  20.     public int getAge(){
  21.         return this.age;
  22.     }
  23.     public String getInfo(){        // 信息输出
  24.         return "姓名:" + this.getName() + ";年龄:" + this.getAge() ;
  25.     }
  26. }
  27. class Student extends Person{
  28.     private String school;
  29.     public Student(String name,int age,String school){
  30.         super(name,age);
  31.         this.setSchool(school);
  32.     }
  33.     public void setSchool(String school){
  34.         this.school=school;
  35.     }
  36.     public String getSchool(){
  37.         return this.school;
  38.     }
  39.     public String getInfo(){
  40.         return super.getInfo()+"学校"+this.getSchool();
  41.     }
  42.     
  43. }
  44. public class Thisi{
  45.     public static void main(String args[]){
  46.         Student st1=new Student("张三",28,"北大");
  47.         System.out.println(st1.getInfo());
  48.     }
  49. }


1.方法的覆盖

点击(此处)折叠或打开

  1. /* 掌握子类对象的实例化过程
  2. 掌握方法覆写的概念及实现
  3. 在子类中可以根据需要对从父类中继承来的方法进行改造—方法覆盖(方法的重置、重写)覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。覆盖方法不能使用比被覆盖方法更严格的访问权限
  4. 掌握super关键字的作用 */
  5. class Person{
  6.     void print(){
  7.         System.out.println("Person-->void print()");
  8.     }
  9. }
  10. class Student extends Person{
  11.     public void print(){
  12.         /*super调用父类中的方法*/
  13.         super.print();
  14.         System.out.println("Student-->void print()");
  15.     }
  16. }
  17. public class Thisi{
  18.     public static void main(String args[]){
  19.         new Student().print();
  20.     }
  21. }
属性的覆盖

点击(此处)折叠或打开

  1. /* 属性的覆盖
  2. super调用父类中的方法或属性
  3.  */
  4. class Person{
  5.     public String info="MLDN";
  6. }
  7. class Student extends Person{
  8.     public String info="LXH";
  9.     public void print(){
  10.         System.out.println("父类中的属性"+super.info);
  11.         System.out.println("子类中的属性"+info);
  12.     }
  13. }
  14. public class Thisi{
  15.     public static void main (String args[]){
  16.         new Student().print();
  17.     }
  18. }






继承

点击(此处)折叠或打开

  1. /*继承的基本语法特点*/
  2. /*继承就是一个类的得到了另外一个类的成员变量和成员方法。
  3. 类继承语法规则:

  4.  < 修饰符> class < 子类名称> [extends < 父类>]
  5.     {
  6.         <属性和方法的声明>
  7.       }
  8. 类通过getter访问父类中的属性
  9. */
  10. class ManKind{
  11.     int sex;
  12.     int salary;
  13.     public void manOrWoman(){
  14.         if(sex==1)
  15.             System.out.println("Man");
  16.         else System.out.println("Women");
  17.     }
  18.     public void employed(){
  19.         if(salary==0)
  20.             System.out.println("No job");
  21.         else System.out.println("job");
  22.     }
  23. }
  24. public class Thisi extends ManKind{
  25.     int yearsOld;
  26.     void printAge(){
  27.         System.out.println("age="+yearsOld);
  28.     }
  29.     public static void main(String args[]){
  30.         Thisi THI=new Thisi();
  31.         THI.sex=1;
  32.         THI.salary=0;
  33.         THI.manOrWoman();
  34.         THI.employed();
  35.         THI.yearsOld=28;
  36.         THI.printAge();
  37.     }
阅读(1294) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~