java 基础学习-02 基础中的理解点

问题一1.关于为什么静态函数中不能使用非静态变量。及this 和静态变量的使用 

public class Students {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		person p1=new person();
		p1.name="张三";
		person p2=new person();
		p2.name="李四";
		p1.talk();
		p2.talk();
		
		person.code=25;//静态变量可以使用 类名.变量来使用 
		//下面代码 我们证明所有对象使用的是同一个静态变量 ，静态变量不属于某一个对象，而是属于类
		System.out.println(p1.code);
		System.out.println(p2.code);
		p1.code=50;
		System.out.println(p1.code);
		System.out.println(p2.code);
		//此处理解 静态函数 不能使用非静态变量   解释在 方法的注释中
		person.talkage();
	}

}

public class person {
	static {
		System.out.println("此处的是 静态代码块" );
		//类在加载时 就先执行此方法  主要用于 静态变量的赋值
	}
	String name;
	int age;
	static int  code;
	public person() {
		// TODO Auto-generated constructor stub
		
	}
	public person(String name2) {
		// TODO Auto-generated constructor stub
		this.name=name2;
	}public person(String name2,int age2) {
		// TODO Auto-generated constructor stub
		this(name2);//this 可以调用构造 函数   要求 参数相同
		this.age=age2;
	}


	void talk() {
		System.out.println("我的名字" + name);
		//这里打印的name 则是 this.name   实际上这句话是从输出的System.out.println("我的名字" + this.name);
		
	}


	void talk(String name) {
		System.out.println("我的名字" + name);
		//这里打印的name 而是 传入的name
		
	}
	static void talkage() {
		//此处是报错的  因为 无法引用非静态的变量  Cannot make a static reference to the non-static field age
		System.out.println("我的编码" + age);
		/*解释： 假如说我们可以使用非静态变量
		呢么这个age 打印的 是对象.age 也就是this.age 
		呢么 this怎么解释呢，先前我们说过this代表调用函数的那个对象 问题是 静态函数是用类名来调用 
		没有对象，所以此时没有对象 只有类。所以this就解释不通
		*/
		
	}
}
			

问题2.super  继承中的问题

@Override
	public void talk(){
		super.talk();

//继承了父类的方法之后  有这个super；则执行 父类方法中的代码块和子类的代码块，。如果没有则不执行 父类方法的代码，只执行子类的代码块
		System.out.println("子类的 讲话");
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		man s1=new man();
		s1.setName("狗子哦");
		s1.talk();
}

问题3.关于权限的问题

private 只供本类使用  即使继承了 子类也不能用

default：同一个包下  皆可访问。

protected：只可以修饰变量和函数。 其他包中不可使用，同一个包下可以使用

问题4.关于接口

方法全是抽象方法。并且权限权都为public权限。

问题5.关于抽象类的问题。

1.抽象类不能够生成对象 不可以new

2.含有抽象函数的类必须被声明为抽象类；

3.构造函数用于生成对象，抽象类可以有，但是没有意义。因为1。这里可以super使用其中的代码

问题6.关于继承的 上下转型

转型是在继承的基础上而言的，继承是面向对象语言中，代码复用的一种机制，通过继承，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。

向上转型：子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口

向下转型：父类引用的对象转换为子类类型称为向下转型。

前者是一个向上转型，Animal dog 引用指向new Dog();子类对象当成父类对象，只能调用父类的成员，如果子类重写了父类的方法就根据这个引用指向调用子类重写的这个方法（这个方法就是覆盖override）。这个调用过程就称为“动态绑定”。

转型需要注意的问题：

向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。实例如下：

public class www {
public static void main(String[] args) {
        Animalll b=new Bird(); //向上转型
        b.eat();
 <span style="white-space:pre">		</span>b.fly();  //此处提示在Animal中没有定义fly方法。
}}

class Bird extends Animalll{
public void eat(){
        System.out.println("bird eatting...");
}
public void fly(){
        System.out.println("bird flying...");
}
}
class Animalll{    
public void eat(){
        System.out.println("animal eatting...");
}
}

在向下转型过程中，分为两种情况：

情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。

情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。实例如下：

public class testt {
	public static void main(String[] args) {
		women g1 = new Girl(); // 向上转型 父类指向 子类    new 子类的对象
		g1.smile();
		Girl mmg = (Girl) g1; // 向下转型, 父类对象   转换为子类  ，编译和运行皆不会出错  
		mmg.smile();
		mmg.c();
		System.out.println("---------------------------------");
		/*******
		 * 下面这种转型是错误的
		 */

System.out.println("----------------");
if (g2 instanceof Girl) {

System.out.println("两个同一个东西的");}else {
System.out.println("两个不是同一个东西的");}

		Girl mmg22=(Girl)g2; //不安全的向下转型,编译无错但会运行会出错
		mmg22.smile();
		mmg22.c();
	
	}
	
}

class Girl extends women {
	@Override
	public void smile() {
		System.out.println("Girl smile sounds sweet...");
	}
	public void c() {
		System.out.println("Girl c()...");
	}
}

class women {
	public void smile() {
		System.out.println("women smile()...");
	}
	
}

总结：

1、父类引用可以指向子类对象，子类引用不能指向父类对象。

2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。

　　 如Father father = new Son();

3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。

　　 如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son）father；

　　 其中father前面的（Son）必须添加，进行强制转换。

4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效

5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

问题7.关于异常 异常的处理两种方式

public class personll {
	private String name;
	public String getName ( )  throws Exception {
		//首先这种处理异常方式  在调用的地方处理
		if(name.length()>5){
			Exception e=new Exception();
			throw e;
		}
		return name;
		
	}
	public void setName(String name) {
		
		this.name = name;
		
	}
	public int getAge() {
		//这种处理的方法   直接处理  
		try {//如果年龄 小于0 呢么 加上 30岁
			if(age<0){
			int	addage=age+30;
				System.out.println("若是先执行try   此处代码 则 年龄增加 30 之后的代码"+addage);
				return age+30; 
			}
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
			System.out.println(e1);
		}
		finally {
			int	addage=age+50;
			
			System.out.println("若是先执行  finally 处代码 则 年龄为  加 50 之后的 年龄"+addage);

			return age+50; 
		}
	}
	public void setAge(int age) {

		System.out.println("赋值为"+age);
		System.out.println("年龄减少 了20岁");
		this.age = age-20;
		System.out.println("年龄减少 了20岁 之后的年龄为  "+this.age);
	}
	private int age;
	void introduce(){
		System.out.println("这是父类的");
	}
}

public class man   {
	public static void main(String[] args){
		personll per=new personll();
		per.setAge(15);
		per.setName("as666666");
		System.out.println("年龄"+per.getAge());
		try {
			System.out.println("名字"+per.getName());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.out.println("如果名字长度 大于五 则  输出这句");
		}
	}
}

  如果代码有问题或者有什么错误请 联系

 qq 1243087956