Java基础学习笔记1

一边看codingke的视频，一边敲的代码，编辑于下，方便复习看之

从继承到多态（花了大半天的时间，主要是还没有进入状态，感觉好像还有很多很多东西等着学，20160108）

【扣丁学堂】

Test11主要是对super（）的理解，父类中有带参的构造函数时，子类继承父类时要使用super（）

package practice05;
/*
* 继承
* 允许多继承，父类，子类，子类的子类
* 在子类进行实例化时，首先实例化父类（调用父类的构造方法），再实例化子类
*/
public class Test11 {
public static void main(String[] args){
Dog dog1=new Dog("dog");
dog1.print();
dog1.desc();
}
}
//父类
class Animal{
//如果属性需要被子类继承,那么可以使用protected关键字声明
public Animal(String name){
System.out.println("animal");
}
protected String name;
protected void desc(){
System.out.println("animal name is "+name);
}
}
//子类
/*
* extends在java中是单继承
*/
class Dog extends Animal{
//构造方法
public Dog(String name){
/*
* 当父类中没有无参的构造函数是，子类中要使用super
*/
super(name);//显示的调用父类的构造方法，在构造方法的第一行
System.out.println("dog");
this.name=name;
}
public void print(){
System.out.println("my name is "+name);
}
//重写
public void desc(){
super.desc();//调用父类的方法，调用属性也相同
System.out.println("dog name is "+name);
}
}

Test12写了一个关于管理商品的例子
里面有一个关于数组扩充的函数（这一点在c中好像只能用malloc实现了），还有一条语句{cosme[count]=cos;}，便于对栈和堆的理解，相当于c中的指针

package practice05;
import java.util.Arrays;
public class Test12 {
public static void main(String[] args){
//
}
}
class Cosmetic{
private double money;
private String name;
public Cosmetic(double money,String name){
this.money=money;
this.name=name;
}
public double getMoney(){
return money;
}
public void setMoney(double money){
this.money=money;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public String infor(){
return name+" :"+money;
}
}
class CosmeticManager{
Cosmetic []cosme=new Cosmetic[3];
int count=0;
public void adding(Cosmetic cos){
if(count==cosme.length){
int len=cosme.length*3/2+1;
cosme=Arrays.copyOf(cosme, len);
}
cosme[count]=cos;//注意着调语句
//		cosme[count].setMoney(cos.getMoney());
//		cosme[count].setName(cos.getName());
count++;
}
public void printInfor(){
for(int i=0;i<count;i++){
System.out.println(cosme[i].infor());
}
}
}
class SortCosmeticManager extends CosmeticManager{
//
}

Test13是讲final（只是了解大概）

package practice05;
/*
* final声明的类不能被继承
* final声明的方法不能被重写
* final声明的属性可以有两种赋值
*/
public class Test13 {
public static void main(String[] args){
//
}
}
class ParentClass{
private final int num=10;
private final int count;
public ParentClass(){
count=100;
}
public final void method(){
//
}
}
class SubClass extends ParentClass{
//
}

Test14开始讲abstract ，给我的感觉和继承一样

package practice05;

public class Test14 {
public static void main(String[] args){
Man m=new Man();
m.eat();
Woman y=new Woman();
y.eat();
}
}
/*
* 具体类继承抽象类必须要实现抽象方法
*/
class Man extends Person{
public void eat(){
System.out.println("eating with quick");
}
}
class Woman extends Person{
public void eat(){
System.out.println("eating with slowly");
}
}
/*
* 有抽象方法的一定是抽象类，是抽象类不一定是抽象方法
* 抽象方法不能被实例化
* 抽象类似不能被用final，因为就是要被继承的
*/
abstract class Person{
private String name;
public abstract void eat();//没有实现，抽象方法
}

Test15讲的是interface

package practice05;
/*
* 接口（是一种行为）
* 接口是一组行为的规范，定义，没有实现
* 使用接口，可以让我们的程序更加利于变化
* 接口可以继承多个接口（例子？？）
* 一个类可以实现多个接口
* 抽象类实现接口可以不实现方法
* 接口中的所有方法的访问权限都是public
* 接口中定义的属性都是常量
*/
public class Test15 {
public static void main(String[] args){
//
}
}
class Girl implements Hit{
public void cry(){
System.out.println("crying");
}
public void eat(){
System.out.println("eating continually");
}
}
interface Eat extends Hit{
public void eat();
//下面的default不懂？？
public default void print(){
//
}
}
interface Hit{
String info="";//public static final (定义常量的通常方法？？） 属性就是常量
void cry();//在接口中的方法默认为public
}

Test16讲多态

用abstract来说明，不过这个例子的重要之处在于父类引用子类对象（似乎像是父类获得了子类的一切方法）

最后提了一下instanceof来判断强制转换是否可以

package practice05;
/*
* 多态（有点不懂？？？）
* 父类可以代表子类，但是子类不能代表父类（向上转化）
*/
public class Test16 {
public static void main(String[] args){
HomeCat hoc=new HomeCat();
hoc.eat();
YeCat yec=new YeCat();
yec.eat();
/*
* 用父类的引用指向子类对象,便于扩展
* 父类一般用接口或者是抽象类（越抽象越好）
*/
Cat cat=new HomeCat();
/*
* 向下转型（大转小，父类转子类）
* 容易有异常
* 例
* Cat cat=new YeCat();
* HomeCat hoc=(HomeCat)cat;
* 本身是YeCat
*/
/*
* instanceof判断类型是否可以转，可以就转，不可以就不转
*
* if(cat instanceof HomeCat){
HomeCat hc=(HomeCat)cat;
}
*/

//		HomeCat hc=(HomeCat)cat;
print(cat);
}
//多态
public static void print(Cat cat){
cat.eat();
}
}
class HomeCat extends Cat{
public void eat(){
System.out.println("family cat eating with slowly");
}
}
class YeCat extends Cat{
public void eat(){
System.out.println("outdoor cat eating with quickly");
}
}
abstract class Cat{
public String name;
public abstract void eat();
}

Test17 讲模板，不过觉得还是多态

package practice05;
//多态，模板
public class Test17 {
public static void main(String[] args){
//
}
}
class Girl2 extends Games{
public boolean putHand(){
//一种写法
java.util.Random r=new java.util.Random();
return r.nextBoolean();
}
}
class ModelGirl extends Games{
public boolean putHand(){
return false;
}
}
abstract class Games{
public void play(){
System.out.println("play");
System.out.println("outcome :");
if(putHand()){
System.out.println("accepted");
}else{
System.out.println("play again");
}
}
public abstract boolean putHand();
}

Test18 大综合，用接口来实现抽象类属性的多态

package practice05;
/*
* 接口应用-策略模式
* OO设计原则：
* 1.面向接口编程（面向抽象编程）
* 2.封装变化
* 3.多用组合，少用继承
*
*/
public class Test18 {
public static void main(String[] args){
Duck black=new BlackDuck("xiaohei");
black.setFly(new FlyImpl());
black.fly();

Duck model=new ModelDuck("wanju");
model.setFly(new NoFlyImpl());
model.fly();
}
}
interface Flyable{
public void fly();
}
class FlyImpl implements Flyable{
public void fly(){
System.out.println("I can fly");
}
}
class NoFlyImpl implements Flyable{
public void fly(){
System.out.println("I cann't fly");
}
}
abstract class Duck{
private String name;
private Flyable flyy;
public void setFly(Flyable flyy){
this.flyy=flyy;
}
public Duck(String name){
this.name=name;
}
public void fly(){
System.out.println("我的名字是"+name);
flyy.fly();
//	System.out.println("I'm a Duck flying very hightly");
}
}
//真鸭子
class BlackDuck extends Duck{
public BlackDuck(String name){
super(name);
}
}
//玩具鸭子
class ModelDuck extends Duck{
public ModelDuck(String name){
super(name);
}
/*	public void fly(){
System.out.println("I'm a Duck with unable to fly");
}*/
}