[Java] java学习2 →→→→→进入此内容的聊天室

来自 , 2020-12-06, 写在 Java, 查看 121 次.
URL http://www.code666.cn/view/db957c62
  1. //写代码一定要保存,不然总是会报错,还查不出来,切记!当保存成为习惯就没有这个问题了
  2.  * 面向对象:三大特点(封装,继承,多态),。这只是面向对象的,java的特点有很多,可移植,健壮,
  3.  *
  4.  *
  5.  * 在多个对象中抽象出来的叫类
  6.  * return 就是一个程序的结束,后面跟的逻辑都是无意义的,main是开始
  7.  *  但程序进入main之前会先找static 然后把带有static的方法和变量放到静态池 静态池是在方法之前编译
  8.  *
  9.  * 生物:动物 植物 细胞  对于动植物来说   生物就是类   类下面有三种对象
  10.  *
  11.  * 对象是类的实例   是一类事物的具体体现
  12.  *
  13.  * 在类中的位置不同  
  14.  * 成员变量:类中,方法外
  15.  * 局部变量:方法中
  16.  * 作用范围不一样  
  17.  * 成员变量:类中
  18.  * 局部变量:方法中
  19.  * 初始化值的不同  
  20.  * 成员变量:有默认值
  21.  * 局部变量:没有默认值。必须先定义,赋值,
  22.  *  生命周期不同
  23.  *  成员变量:随着对象的创建而存在,随着对象的消失而消失
  24.  *  局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
  25.  *
  26.  * 属性:成员变量:事物的状态信息
  27.  * 方法: 成员方法:对应事物的行为
  28.  *  
  29.  * 类的使用
  30.   方法的命名:修饰符  +  返回值类型   +方法名(数据类型 ){    }
  31.   类的命名:    修饰符  +            +方法名     (  )   {    }
  32.   变量       :    修饰符  +  变量名
  33. JavaBean是类的规范 :必须是具体的,公共的 具有无参构造();写了有参,若不写无参,默认无参就不在生效
  34.  
  35. java中构造方法指的是:与类名相同,无返回类型的方法,参数可以为空,也可以带参数。
  36. 比如一个 Point 类,private Point(){}这个就是无参数的构造方法。
  37. private Dao(int x0, int y0){}这个就是带参数的构造方法。
  38. 作用:用来初始化 java 类,提供类的初始化和实例化,即可以通过new来创建对象以便调用。
  39. 如果想在实例化对象的时候就为这个属性赋值的话,可以通过有参构造实现。
  40.  
  41.  
  42. public:对所有类可见  
  43.  
  44. protected:对同一包中的类可见、对同一包及不同包中的子类可见
  45.  
  46. default:对同一包中的类可见、对同一包中的子类可见
  47.  
  48. private:仅对类本身可见   封装 修饰成员变量被  
  49. private修饰后的成员变量和成员方法,只在本类中才能访问
  50.  
  51. 可见是可访问的意思,即由这些修饰符修饰的成分(类、方法、成员变量)可以被其它类
  52. 访问。对子类可见即子类可以继承。
  53.  
  54. 这里需要注意的是protecteddefault,二者的区别在于不同包中的子类是否可以继承。
  55.  
  56. 封装的构造方法
  57.  修饰符 当前类名(参数列表){
  58. // 方法体    
  59. }
  60.  
  61.  public class Animal(){   //创建一个类
  62.  private int num;         //定义两个私有变量
  63.  private String name;
  64.  public Animal(){         //构建无参
  65.  }
  66.  public Animal(int num,String name){  //构建有参
  67.  this.num=num;
  68.  this.name=nume
  69.  }
  70.  public int getNum(int num){
  71.  
  72.  return num;
  73.  }
  74.  public void setNum(){
  75.  this.num=num;
  76.  }
  77.  public void cont(){                 //创建方法
  78.  }                                  
  79.  
  80.  }
  81.  
  82.  
  83.  
  84.  public class Cat (){
  85.  public static void main (String [] args){
  86.  
  87.  }
  88.  
  89.  public String getName(){
  90.      //Animal类的句柄     miao是类的对象     new Animal()  :Animal类的空间
  91.  Animal miao=new Animal();      //创建一个Animal对象   miao  需要用到无参构造
  92.  miao.setNum(" mao111");    //私有后的赋值  不私有可直接调用   miao.num=45;
  93.  
  94.  //调用的三种形式:直接调用,赋值调用   输出调用
  95.  类中 : 方法名直接调用
  96.  赋值调用:int sum =getSum(5,6);使用有参构造
  97.  输出调用:syso("有返回值得方法名()");
  98.  重载:同一个类, 方法名相同 型参不同
  99.  重写:子类重写父类中的抽象方法,声明完全一样,增加方法体;子类重写方法权限(public
  100.  )必须大于父类
  101.  
  102.  子类初始化,默认先初始化父类的构造super();父类构造   super父类的引用  this没有继承关系也有本类引用的意义
  103.  object 是所有类的爸爸  this.成员变量  this.成员方法  本类的成员变量和方法
  104.  子类重写父类的构造,实例的调用就可以用父类的构造 若想使用子类的,还有重载,再次构造一个生成器
  105.  super()  this()  都必须在第一行
  106.  继承只能单继承
  107.  但clss A{
  108.         class B extends A{
  109.                 class C extends B{
  110.                 }
  111.         }
  112.  }   这样多层继承就可以解决单一继承的缺点
  113.  abstract 抽象方法  的关键字,但接口的抽象类可以省略
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.                                                      
  124.  
  125.  
  126.  
  127.  }
  128.  
  129.  }
  130.  
  131.  
  132.  
  133. java中四种访问修饰符
  134.  
  135.  
  136.  
  137. Java中的四种访问修饰符:publicprotecteddefault(无修饰符,默认)、private
  138.  
  139.  
  140. •四种修饰符可修饰的成分(类、方法、成员变量)
  141.  
  142.                           public protected default private
  143.                   类         √       ×         √          ×
  144.                    
  145.  
  146.                 方法        √       √         √          √
  147.  
  148.                成员变量   √       √         √          √
  149.  
  150.  
  151.  
  152. •四种修饰符的访问权限
  153.  
  154. public:对所有类可见
  155.  
  156. protected:对同一包中的类可见、对同一包及不同包中的子类可见
  157.  
  158. default:对同一包中的类可见、对同一包中的子类可见
  159.  
  160. private:仅对类本身可见  
  161.  
  162. 可见是可访问的意思,即由这些修饰符修饰的成分(类、方法、成员变量)可以被其它类访问。对子类可见即子类可以继承。
  163.  
  164. 这里需要注意的是protecteddefault,二者的区别在于不同包中的子类是否可以继承。
  165.  
  166. 访问权限 类 同一包 同一包中的子类 不同包中的子类 不同包
  167. public
  168.  
  169.  
  170.  
  171.  
  172.  
  173. protected
  174.  
  175.  
  176.  
  177.  ×
  178. default
  179.  
  180.  
  181.  × ×
  182. private
  183.  × × × ×
  184.  
  185.  
  186. •例如
  187.  
  188. package1:ParentClass、ChildClassOne、TestOne
  189.  
  190. package2:ChildClassTwo、TestTwo
  191.  
  192. package3:TestThree
  193.  
  194. 其中ParentClass为
  195.  
  196. public class ParentClass {
  197.  
  198.         public int a=2;
  199.         protected int b = 3;
  200.         int c = 4;
  201.         private int d = 5;
  202.  
  203. }
  204.  
  205.  
  206.   1.对于TestOne来说,ParentClass类、a、b、c均可见,d不可见。即在TestOne中可以new一个ParentClass对象,且该对象中的a,b,c变量可操作。如下:
  207.  
  208.  
  209.  
  210. public class TestOne {
  211.  
  212.         public static void main(String args[]) {
  213.  
  214.                 ParentClass obj = new ParentClass();
  215.  
  216.                 System.out.println(obj.a);
  217.                 System.out.println(obj.b);
  218.                 System.out.println(obj.c);
  219. //              System.out.println(obj.d);     //d 不可见
  220.         }
  221. }
  222.  
  223.  
  224.   2. ChildClassOne继承ParentClass且与其在同一个包中,则a、b、c均可见,d不可见。
  225.  
  226. public class ChildClassOne extends ParentClass{
  227.  
  228.         public static void main(String args[]) {
  229.  
  230.                 ChildClassOne obj = new ChildClassOne();
  231.  
  232.                 System.out.println(obj.a);
  233.                 System.out.println(obj.b);
  234.                 System.out.println(obj.c);
  235. //              System.out.println(obj.d);      // d不可见
  236.         }
  237. }
  238.  
  239.  
  240.   3. ChildClassTwo继承ParentClass,则a、b均可见,d不可见,由于子类与ParentClass不在同一包中,故c(default类型)不可见。
  241.  
  242. public class ChildClassTwo extends ParentClass{
  243.  
  244.         public static void main(String args[]) {
  245.                 ChildClassTwo obj = new ChildClassTwo();
  246.  
  247.                 System.out.println(obj.a);
  248.                 System.out.println(obj.b);
  249. //              System.out.println(obj.c);    // c不可见
  250. //              System.out.println(obj.d);    // d不可见
  251.         }
  252. }
  253.  
  254.  
  255.  4.对于TestTwo来说,ParentClass类、a均可见,b、c、d不可见。由于TestTwo与ParentClass不在同一个包中,故只有public修饰的成分可见。
  256.  
  257. public class TestTwo {
  258.  
  259.         public static void main(String args[]) {
  260.  
  261.                 ParentClass obj = new ParentClass();
  262.                 System.out.println(obj.a);
  263. //              System.out.println(obj.b);     // b 不可见
  264. //              System.out.println(obj.c);     // c 不可见
  265. //              System.out.println(obj.d);     // d 不可见
  266.         }
  267. }
  268.  
  269.  
  270.  
  271. •另外值得注意的是继承父类的子类与其他类之间的可见性,取决于其他类与父类之间的可见性。
  272.  
  273. 对于TestOne来说,ChildClassOne中a,b,c都可见,d不可见,这是由于TestOne与ParentClass在同一个包中。
  274.  
  275. 而对于TestThree来说,ChildClassOne中只有a可见,这是由于TestThree与ParentClass在不同的包中。
  276.  
  277. 需要注意:
  278.  
  279. 虽然a、b对ChildClassTwo可见,TestTwo与ChildClassTwo在同一包中,
  280.  
  281. 但对于TestTwo来说,ChildClassTwo中只有a可见,这是由于TestTwo与ParentClass在不同的包中,只有public修饰的可见。
  282.  
  283.  *
  284.  *
  285.  *
  286.  *
  287.  *
  288.  *
  289.  *
  290.  *
  291.  * */

回复 "java学习2"

这儿你可以回复上面这条便签

captcha