标签:int sys protected 比较 etl 模版 建模 基础 两种
1 继承(1) 2 类是对对象的抽象,继承是对某一批类的抽象,从而实现对现实世界更好的建模。 3 提高代码的复用性! 4 extends的意思是“扩展”。子类是父类的扩展 5 6 父类:超类、基类、 子类:派生类 7 小结: 8 继承的作用:通过继承可以简化类的定义,实现代码的重用 9 10 子类继承父类的成员变量和成员方法,但不继承父类的构造方法 11 12 –java中只有单继承 ,没有像c++那样的多继承。多继承会引起混乱,使得继承链过于复杂,系统难于维护。就像我们现实中,如果你有多个父母亲,那是一个多么混乱的世界啊。多继承,就是为了实现代码的复用性,却引入了复杂性,使得系统类之间的关系混乱。 13 –java中的多继承,可以通过接口来实现 14 – 15 如果定义一个类时,没有调用extends,则它的父类是:java.lang.Object继继承(1) 16 17 18 子类可以继承父类的所有资源吗? 19 不能,不能被继承的父类成员有 1、private成员 2、子类和父类不再同包,使用默认访问权限的成员 3、构造方法 20 21 本类 同包 子类 所有类 22 public √ √ √ √ 23 Protected √ √ √ × 24 默认 √ √ × × 25 Private √ × × × 26 package finaldemo; 27 /** 28 * 1,用final来修饰一个变量, 则该变量就变成了一个常量 29 * 2,用final来修饰一个类,则该类就不能被作为父类继承 30 * 3,用final来修饰一个方法,则该方法就不能被重写 31 * @author tang 32 * 33 */ 34 public class Test { 35 public static void main(String[] args) { 36 final int AGE; 37 AGE = 10; 38 39 } 40 } 41 42 43 方法的重写(override) 44 在子类中可以根据需要对从基类中继承来的方法进行重写。 45 重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。 46 重写方法不能使用比被重写方法更严格的访问权限。(由于多态) 47 package overwriter; 48 49 public class Pet { 50 private String name; 51 private int health; 52 private int love; 53 54 public Pet() { 55 56 } 57 58 public Pet(String name, int health, int love) { 59 super(); 60 this.name = name; 61 this.health = health; 62 this.love = love; 63 } 64 public void print() { 65 System.out.println(name + health + love); 66 } 67 68 public String getName() { 69 return name; 70 } 71 public void setName(String name) { 72 this.name = name; 73 } 74 public int getHealth() { 75 return health; 76 } 77 public void setHealth(int health) { 78 this.health = health; 79 } 80 public int getLove() { 81 return love; 82 } 83 public void setLove(int love) { 84 this.love = love; 85 } 86 } 87 88 package overwriter; 89 public class Cat extends Pet{ 90 private String color; 91 public Cat(String name, int health, int love, String color) { 92 super(name, health, love); 93 this.color = color; 94 } 95 public Cat() { 96 super(); 97 // TODO Auto-generated constructor stub 98 } 99 @Override 100 public void print() { 101 102 System.out.println(); 103 super.print(); 104 } 105 106 public String getColor() { 107 return color; 108 } 109 110 public void setColor(String color) { 111 this.color = color; 112 } 113 } 114 115 package overwriter; 116 public class Dog extends Pet { 117 //成员变量在最上面 118 private String strain; 119 //成员变量下面写构造方法 120 public Dog() { 121 122 } 123 public Dog(String name, int health, int love, String strain) { 124 super(name, health, love); 125 this.strain = strain; 126 } 127 public String getStrain() { 128 return strain; 129 } 130 public void setStrain(String strain) { 131 this.strain = strain; 132 } 133 } 134 135 package overwriter; 136 137 public class Test { 138 public static void main(String[] args) { 139 Dog wangcai = new Dog("旺财", 100, 100, "哈士奇"); 140 wangcai.print(); 141 142 Cat cat = new Cat("小黑", 100, 90, "黑色"); 143 cat.print(); 144 } 145 } 146 147 需要改写父类中方法的代码 148 package overwriter02; 149 150 public class Pet extends Object{ 151 private String name; 152 private int health; 153 private int love; 154 155 public Pet() { 156 157 } 158 public Pet(String name, int health, int love) { 159 super(); 160 this.name = name; 161 this.health = health; 162 this.love = love; 163 } 164 //宠物发出叫声的方法 165 public void bark() { 166 167 } 168 169 public String getName() { 170 return name; 171 } 172 public void setName(String name) { 173 this.name = name; 174 } 175 public int getHealth() { 176 return health; 177 } 178 public void setHealth(int health) { 179 this.health = health; 180 } 181 public int getLove() { 182 return love; 183 } 184 public void setLove(int love) { 185 this.love = love; 186 } 187 } 188 189 package overwriter02; 190 191 public class Cat extends Pet{ 192 private String color; 193 194 public Cat(String name, int health, int love, String color) { 195 super(name, health, love); 196 this.color = color; 197 } 198 public Cat() { 199 super(); 200 // TODO Auto-generated constructor stub 201 } 202 203 @Override 204 public void bark() { 205 System.out.println("miao miao ..."); 206 } 207 208 public String getColor() { 209 return color; 210 } 211 212 public void setColor(String color) { 213 this.color = color; 214 } 215 216 } 217 218 219 public class Dog extends Pet { 220 221 //成员变量在最上面 222 private String strain; 223 //成员变量下面写构造方法 224 public Dog() { 225 226 } 227 public Dog(String name, int health, int love, String strain) { 228 super(name, health, love); 229 this.strain = strain; 230 } 231 232 @Override 233 public void bark() { 234 super.bark(); 235 System.out.println("won won ..."); 236 } 237 238 public String getStrain() { 239 return strain; 240 } 241 public void setStrain(String strain) { 242 this.strain = strain; 243 } 244 } 245 246 package overwriter02; 247 248 public class Test { 249 public static void main(String[] args) { 250 251 } 252 } 253 254 255 256 为什么需要重写父类的方法? 257 父类实现的方法不符合子类的逻辑 258 父类已经实现了80%,但是子类又必须要使用剩下的20%,所以可以重写父类方法,在方法内用super关键字调用父类的方法,再去完成剩下的20%工作 259 260 super关键字 261 定义:super是直接父类对象的引用。 262 用法:可以通过super来访问父类中被子类覆盖的方法或属性。 263 普通方法: 264 没有顺序限制。可以随便调用。 265 构造函数中: 266 任何类的构造函数中,若是构造函数的第一行代码没有显式的调用super(...);那么Java默认都会调用super();作为父类的初始化函数。 所以你这里的super();加不加都无所谓。 267 268 final关键字 269 定义:final可以用来修饰变量,方法,类。 270 修饰变量 变量一旦被初始化便不可改变 相当于定义了一个常量 271 修饰引用数据类型 引用不能被赋值 但属性可以被赋值 272 修饰方法 final方法是在子类中不能被覆盖的方法 273 修饰类 final类是无法被任何类继承的 274 package finaldemo; 275 /** 276 * 1,用final来修饰一个变量, 则该变量就变成了一个常量 277 * 2,用final来修饰一个类,则该类就不能被作为父类继承 278 * 3,用final来修饰一个方法,则该方法就不能被重写 279 * @author tang 280 * 281 */ 282 public class Test { 283 public static void main(String[] args) { 284 final int AGE; 285 AGE = 10; 286 287 } 288 } 289 package finaldemo; 290 291 public class Pet { 292 public final void test() { 293 System.out.println("test"); 294 } 295 } 296 package finaldemo; 297 298 public class Dog extends Pet{ 299 300 } 301 302 303 Object类 304 object类是所有java类的根基 305 如果在类的声明中未使用extends关键字指明其基类,则默认基类为object类 306 public class Person { 307 ... 308 } 309 public class Person extends Object { 310 ... 311 } 312 package objectdemo; 313 314 public class Dog { 315 private String name; 316 private int age; 317 318 public Dog(String name, int age) { 319 super(); 320 this.name = name; 321 this.age = age; 322 } 323 public Dog() { 324 super(); 325 // TODO Auto-generated constructor stub 326 } 327 328 329 @Override 330 public boolean equals(Object dog) { 331 //做类型转换 将Object类型的参数转换为Dog类型的参数 332 Dog dahuang = (Dog)dog; 333 //如果两个对象的名字是相同的,则认为是相同的对象 334 boolean b = this.name.equals(dahuang.name); 335 return b; 336 } 337 338 //当使用system.out.println 来打印一个对象的时候 就是在答应对象toString方法的返回值 339 @Override 340 public String toString() { 341 return "Dog [name=" + name + ", age=" + age + "]"; 342 } 343 public String getName() { 344 return name; 345 } 346 public void setName(String name) { 347 this.name = name; 348 } 349 public int getAge() { 350 return age; 351 } 352 public void setAge(int age) { 353 this.age = age; 354 } 355 } 356 package objectdemo; 357 public class Test { 358 public static void main(String[] args) { 359 Dog wangcai = new Dog("旺财",11); 360 Dog dahuang = new Dog("旺财", 10); 361 362 System.out.println(wangcai.equals(dahuang)); 363 System.out.println(wangcai.toString()); 364 } 365 } 366 367 368 重写: toString 方法: 369 默认返回:包名+类名+@+哈希码 370 可以重写! 371 372 抽象类 373 定义:是一种模版模式。抽象类为所有子类提供了一个通用模版,子类可以在这个模版基础上进行扩展。 374 作用: 通过抽象类,可以避免子类设计的随意性。通过抽象类,我们就可以做到严格限制子类的设计,使子类之间更加通用。 375 package 抽象类; 376 /** 377 * class 前加abstract 该类就成为了一个抽象类 378 * 1,抽象类不能创建对象 379 * 2,抽象类一般是一个父类,该父类没有什么存在的意义,就是用来被子类继承 380 * 3,抽象类中可以有抽象方法,也可以有非抽象方法 381 * 4,一个类继承了一个抽象类,则该类必须要实现该抽象类中的所有抽象方法 382 * 5,如果子类也是抽象类,则可以不实现父类的抽象方法 383 * 6,抽象方法必须定义在抽象类中 384 * 385 * 386 * 为什么要使用抽象类 387 * 388 * @author tang 389 * 390 */ 391 public abstract class Pet { 392 private String name; 393 //抽象方法 394 //如果一个方法 每个子类实现的逻辑都不一样 则把该方法定义成抽象方法, 395 //让每个子类去根据自己的逻辑实现该方法 396 public abstract void bark(); 397 public abstract void eat(); 398 public abstract void sleep(); 399 public abstract void play(); 400 401 //如果一个方法,每个子类实现的逻辑都一样 则该方法直接在父类中实现,子类直接调用 402 public String getName() { 403 return name; 404 } 405 public void setName(String name) { 406 this.name = name; 407 } 408 409 } 410 411 package 抽象类; 412 413 public class Dog extends Pet{ 414 415 @Override 416 public void bark() { 417 System.out.println("won won won..."); 418 } 419 420 @Override 421 public void eat() { 422 System.out.println("狗喜欢吃骨头"); 423 } 424 425 @Override 426 public void sleep() { 427 System.out.println("狗在睡觉。。。"); 428 } 429 430 @Override 431 public void play() { 432 System.out.println("狗在玩飞盘。。。"); 433 } 434 435 } 436 package 抽象类; 437 438 public class Cat extends Pet{ 439 440 @Override 441 public void bark() { 442 System.out.println("maio miao ..."); 443 } 444 445 @Override 446 public void eat() { 447 System.out.println("猫在吃鱼。。。"); 448 449 } 450 451 @Override 452 public void sleep() { 453 System.out.println("猫在晒太阳。。。"); 454 } 455 456 @Override 457 public void play() { 458 System.out.println("猫在玩老鼠。。。"); 459 } 460 461 } 462 463 总结: 464 抽象方法和抽象类均必须用abstract来修饰。 465 抽象方法没有方法体,只需要声明不需实现。 466 有抽象方法的类只能定义能抽象类 467 相反抽象类里面的方法不一定全是抽象方法,也可能没有抽象方法。 468 抽象类可以包含属性、方法、构造方法。 469 抽象类不能实例化,及不能用new来实例化抽象类,只能用来被子类调用。 470 抽象类只能用来继承。 471 抽象方法必须被子类实现。抽象类的子类必须覆盖所有的抽象方法才能被实例化,否则还是抽象类 472 构造方法调用顺序: 473 根据super的说明,构造方法第一句 总是:super(…)来调用父类对应的构造方法。 474 先向上追溯到Object,然后再依次向下执行类的初始化块和构造方法,直到当前子类为止 475 476 对象的比较—==和equals() 477 ==: 478 比较两基本类型变量的值是否相等 479 比较两个引用类型的值即内存地址是否相等,即是否指向同一对象 480 equals() : 481 两对象的内容是否一致 482 483 自定义类须重写equals(),否则其对象比较结果总是false。 484 package equalsdemo; 485 /** 486 * 判断相等的两种方式 487 * 488 *1, == 489 * 用来判断基本数据类型的数据是否相等 490 * 也可以用来判断引用数据类型 判断两个引用是否相等 当且仅当两个引用指向的是同一个对象 == 判断才返回true 491 * 492 * 493 *2,equals 494 * 判断引用数据类型的对象是否相等 495 * 如果一个类没有重写该方法,则自动调用到Object中的equals 判断规则跟 == 一样 496 * 如果要自定义判断相等的规则,则在本类中重写equals 方法,在方法内定义比较规则 497 * @author tang 498 * 499 */ 500 public class Test { 501 public static void main(String[] args) { 502 String str01 = "abc"; 503 String str02 = new String("abc"); 504 505 System.out.println(str01 == str02); 506 System.out.println(str01.equals(str02)); 507 508 } 509 }
标签:int sys protected 比较 etl 模版 建模 基础 两种
原文地址:https://www.cnblogs.com/meizhoulqp/p/11280448.html