java基础总结

JAVA基础

• 数据类型
• 流程控制
• 面向对象
• 封装、继承、多态

1. 数据类型：
   8种主数据类型：byte short(2byte) int(4byte) long(8byte) char(2byt) float(4byte) double(4byte) boolean
   float 类型需要在数据后面加上f: float a = 3.14f
   强制数据类型转换需注意转换精度
   浮点类型在内存中的存储方式：
   比如1314.88f，对应的2进制数为 10100100010.1110000101000111111111...,根据IEEE 754标准， float类型由符号位(1位) + 指数位(8位) + **尾数(23位)**组成
   符号位 0表示 正 , 1 代表负
   指数位为 01110101 (指数-10+127)
   尾数为: 01001000101110000101000
   所以1314.88的浮点数表示为: 0 01110101 01001000101110000101000
   引用类型 String 数组[] 对象引用类型
   对于引用变量来说，变量值是取得特定对象的位表示法， 实际变量存在于堆 上

Book b =new Book();
Book c = new Book();
Book d =c; //声明d,c同时引用到同一个对象, 相当于拷贝两份相同的引用地址
c = b; //c,b 引用相同的对象
c = null; //变量c为空指针引用

数组 ： 数组类型可以按照位置索引快速、随机的存取元素，数组中的每个元素都是变量，可以是8种基本数据类型或是引用类型，注意引用类型数组保存的是引用，而不是对象本身。
1.数组本身是个对象
2. 数组声明

// 数组
int[]  nums = new int[] {0,1,2,3,4,5};
int[] nums =new int[6];
nums[0] = 0;
num[1] =1;
// 非主数据类型数组的创建
Dog[]  pets = new Dog[7];   //创建大小为7的Dog数组，并赋值给Dog[] 类型变量pets
pets[0] = new Dog(); //现在只是有了对Dog的引用， 单缺少了实际的Dog对象，所以需要创建新的Dog对象并赋值给数组元素
pets[1] = new Dog();

2. 流程控制
   条件判断：
   if-else

// if 条件判断
if( 1+1 ==2){
System.out.println("上班！")
}else{System.out.println("休息”)};

switch-case

switch(int){
case 1: System.out.println("Monday");
case 2: System.out.println("Tuesday");
case 3: System.out.println("Wednesday");
case 5: System.out,println("Friday");
Default: System.out.println("not today");
}

循环

//wile和do while循环
int i = 1, product;
while( i<11){
product *= i;
i++;
System.out.printf(" %d *10 = %d\n", i, product);
}

// for循环
int sum = 0;
for(int i = 1; i<=100; i++){
sum += i;
}
System.out.println(sum);

//经典的素数问题 输出前50个素数
int count = 0;
boolean isPrime = true;
for(int i=1; count<=50; i++){
	for( int j=1; j<=Math.sqrt(i); j++){
		if(i%j ==0){
		isPrime = false;
		break;}
 	isPrime = true;
    }
    if(isPrime){ 
		System.out.println(i);
		count++:
	}
}

3. 面向对象
   Java作为一门面向对象设计的语言，我们关注的焦点是对象属性及其行为。将属性类似的对象归为一类(class)，对象是类的实例，对象可以拥有类的行为/方法。

• java程序的执行过程： Java源代码 .java文件 --> Javac编译器编译成字节码 .class --> Java虚拟机(JVM)运行字节码
• main函数
  JVM启动执行时，会寻找命令行所在的类，开始执行这个类的main(),然后一直运行到main的所有程序代码结束 – 《Head First Java》

//类的创建
class Dog{
	int size;
	String breed; //种类
	String name; 
	void bark(){
		System.out.println("Ruff!");
	}
}	
class DogTest{
	pubulic static void main(String[] args){
		Dog d = new Dog(); //创建新的Dog实例对象并用d引用
		d.size = 40; //.圆点运算符存取对象的属性和行为
		d.bark();
	}
}

4. 面向对象三大特征： 封装、继承、多态

• 封装
  何为封装？封装的目的是什么？如何实现封装？
  隐藏实例变量，避免实例变量的直接存取就是封装
  封装目的是保护数据，防止数据被随意修改， 可以通过创建setter/getter方法来实现封装。例如将实例变量访问权限设置为private，然后调用public getter/setter方法实现存取。
• 继承
  继承的目的是为了提高代码的适应性，避免代码的重写。
  继承的特性
  Java中的类是单继承的
  子类继承父类的所有成员变量
  构造方法不会被继承
  子类可以增加成员，可以重新定义继承的成员，但是不能删除
  访问权限
  子类不能访问父类中的私有成员，可以访问public protected 成员
  子类可以访问当前包中缺省成员

// 继承举例
class Person{
	protected String name; //可以将private 改为protected
	public Person(){      //子类默认调用父类无参构造方法，如果需要显示调用，则用super();
	this.name = "James";
	}
	public Person(String name){
		this.name = name;
	}
}
class Student extends Person{
	private int number;
	public Student(){
		number = 8;
	}
	public void show(){
		System.out.println("姓名：" + name +"\n学号：" + number); //编译报错，因为private父类成员变量是不能被继承的
	}
}
class GoodStudent extends Student{
	private double score;
	private String teacher;
	public GoodStudent(){
		score = 90;
		teacher = "李老师”；
		}
	public GoodStudent(double score, String teacher){
	this.sccore = score;
	this.teacher = teacher;
	}
	public void display(){
	super.show(); //子类调用父类的方法
	System.out.println("分数：" + score +"\n班主任" +teacher);
	}
}
public class main{
	public static void main(String[] args){
		GoodStudent s = new GoodStudent();
		s.display();
	}
}

注意：当类中没有声明构造方法时，Java提供默认的构造方法，同时子类会默认调用父类的无参构造方法； 子类可以通过super()调用父类构造方法；子类可以通过父类的方法调用父类的private变量；子类父类中可以有同名的变量，这两个变量是不相关的

• 多态
  何为多态？ 多态实现的条件？
  父类类型可以引用子类对象
  继承 重写
  多态主要有方法多态和类型多态
  注意区分overload override: overload 重载，两个方法名称相同，参数不同； override 重写，子类对父类的方法重新编写，但返回值类型和形参不能改变。

// java多态， override
class Animal{
public void move(){
	System.out.println("动物可以移动");
	}
}
class Dog extends Animal{
	public void move(){
	System.out.println("狗可以快速奔跑");
	}
}
public class TestDog{
	public static void main(String[] args){
		Animal a = new Animal();
		Animal b = new Gog();
		a.move; //执行Animal类的方法
		b.move;  //执行Gog类的方法
	}
}

继续看一个多态的例子，个人觉得很经典的体现了多态：

	public class A{
		public void show(A obj){
			System.out.println("Q");
		}
		public void show(C obj){
			System.out.println("W");
		}
		public void show(){
			show2();
		}
		public void show2(){
			System.out.println("A");
		}
	public class B extends A{
		public void show(B obj){
			System.out.println("E");
		}
		public void show(A obj){
			System.out.println("R");
		}
		public void show2(){
			System.out.println("S");
		}
	public class C extends B{
		public void show(C obj){
			System.out.println("T");
		}
		public void show2(){
			System.out.println("D");
		}
	public static void main(String[] args){
		A a1 = new A();
		A a2 = new B();
		B a3 = new C();
		B b = new B();
		C c = new C();
		
		a2.show(c); //W
		a1.show(b); //Q
		a2.show(b); //Q
		a3.show(c); //T
		a3.show(); //D
}

方法调用的优先级：
this.show(O)>super.show(O)>this.show((super)O)>super.show((super)O)
多态还有两个重要的实现方式： ·抽象类abstract 接口 interface
什么是抽象类？ 什么是接口？

• 抽象类就是不能初始化实例变量的类

abstract public class Canine extends Animal{
	public void roam(){
		}
	public class TestCanine{
		public void go(){
			Canine c = new Canine();  //编译器报错
			c.roam();
		}
}

子类必须实现父类的抽象方法
抽象类可以有非抽象的方法
一旦方法中有抽象的方法，该类必须设置为abstract 类

• 接口是100%纯抽象的类，只有抽象的方法
• 不同继承树的类可以实现相同的接口， 子类不能继承多个类，但是可以实现implements 多个接口