java基础学习笔记

JAVA学习笔记

反射的作用：实现框架的功能

public static void main([String[] args) throws Exception{

一个程序就是一个世界

变量就是程序的基本组成单位

Java类型（整数类型-128-127  浮点型  布尔型 字符型）

byte 1个字节

short 2个字节

int  4个字节

long 8个字节

一个字节=8位

在java中，对char进行运算，直接当做ascii码运算

程序是顺序执行的

Java里面的小数默认为double

a++ -->a=a+1;

try{

         /* IputStreamReader isr=new InputStreamReader(System

BUfferedReader br=new BufferdReader(isr);*/

BufferdReader(new InputStreamReader(Syetem))

}catch{Exception e)

{

e.printStaticTrace();

}

思考题：打印如下图形

      *

      **

      ***

      ****

public class Ti {

public  static  void main (String  args[]){

int lay=4；

for(int i=1;i<=lay;++)

{

   for(int k=1;k<=lay-1;k++)

{  System.out.print(""+"/n");

}

for(int j=1;j<=(i-1)*2+1;j++){

System.out.print("*");

}

}   

}

——————————

Person a=new Person()

a.age=10;

a.name=''小明"；

person b;

b=a;

System.out.println(b.age)

___________

垃圾回收机制：当看到内存不足时，就去跑一圈，

看看哪些是垃圾，并将其回收 。c=null;

_______________________

类 成员方法的定义

public 返回数据类型 方法名（参数列表){

语句

}

public  class Test{

public static void main(String args[])

{

  Person p1=new Person();

//调用方法

pl.speak();

p1.jiSuan();

p1.jiSusn(100);

System.out.println("结果是"+pl.jiSuan(12,23);

}

class Person

{

  int age;

  String  name;

public void speak()

{

System.out.println("我是一个不太会的人"）：

}

public void jiSuan()

{

    int result=0;

    for(int i=1;i<=100;i++)

    {

         result +=i;

      }

  System.out.println("结果是"+result）;

//带1个参数的成员方法

public void jiSuan(int n)

{

int result=0;

for(int i=1;i<=n;i++)

{

  result+=i;

}

System.out.println("结果是"+result）；

}

//带两个参数的成员方法

public void jiSuan(int i,int j){

//return i+j;

int result;

result=i+j;

System.out.println("结果是"+result);

)

//返回值类型与参数类型要一致

在调用某个成员方法的时候，给出的具体数值的个数要一致

——————————————————————————————

void 表示没有任何返回值

return 表达式；把表达式的值返回给主调函数

————————————————————

Java

1.先设计类

2.然后根据类创建对象

*************

******@******

*********@***

#####################

构造方法（函数）：

（方法名和类名相同 

    没有返回值  

    在创建一个类的新对象时，系统会自动的调用该类的构造方法完

    成对新对象的初始化

    一类可以创建多个构造方法

    每一个类都有一个默认的构造方法）

class Person

{

    int age;

    String name;

//构造方法1

public Person(int age,String name)

{

   age=age;

   name=name;

}

public Person(String name)

{

   System.out.println("我是构造2"）;

   name=name;

}

//默认构造方法

person(){};

————————————————————————————————————

this 是属于一个对象的，而不是属于一个类的

只能在类定义的里面使用

/*

作者：ZHIXIN

功能：this的必要性

*/

public class De

{  

     public static void main(String []args)

     {

         Dog dog1=new Dog(2,"大黄"）；

         Person p1=new Person(23,"葛德刚"）;

      }

 class Person

{ 

  int age;

  String name;

  Dog dog;//引用类型

  public Person(Dog dog,int age,String name)

  {

   /* age=age;

    name=name;*/

    this dog=dog;

    this age=age;

    this name=name;

   }

   public void showInfo()

    {

    System.out.println("人名是："+this.name);

    }

   class Dog

  {

   int age;

   String name;

   public Dog(int age,String name)

  {

    this.age=age;

    this.name=name;

   }

   public void showInfo()

   {

     System.out.println("狗名是"+this.name);

    }

}

   

————————————————————————————

类变量是该类的所有对象都可以共享的变量

public class De2

{

     static int i =1;

     static

     {

      i++ ;

     }

    public De2()

    {

     i++;

     }

    public static void main(String []args)

    {

      De2  t1=new De2();

      System.out.println(t1.i);

      De2  t2=new De2();

      System.out.println(t2.i);

     }

}

 

//学生

class Stu

{

    int age;

    String name;

    int fee;

    static int totalFee;

    public Stu(int age,String name,int fee)

    {

      this.age=age;

      this.name=name;

      this.fee=fee;

     }

//用static 表示这是一个类方法（静态方法）

//Java中规则：类变量原则用类方法去方法

   类方法不能去访问非静态变量

    public  static   int  getTotalfee()

    {

     return   totalFee;

     }

}

——————————————————————————

Java面向对象编程四大特征

抽象（把一类事物的共有的属性和行为提取出来，形成一个物理模型的的方法        

封装（把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部）

protected： 对子类和同一个包中的类公开

默认级别 ：向同一个包中的类公开

private：只有类本身可以访问，不对外公开

public：对外公开

继承:私有变量不能被继承，

        子类最多继承一个父类

多态：就是指一个引用（类型）在不同情况的下的多种状态（或

理解为通过指向父类的指针，来调用在不同子类中实现的方法）

注意；Java容许父类引用变量引用它子类的实例饿（对象）

          Animal animal=new Cat();

class Clerk

{

   public static name;

   private int age;

   private folat salary;

   public Clerk(String name;int age,float sal)

   {

     this.name=name;

     this.age=age;

     this.salary=sal;

    }

//通过成员方法去访问私有的属性

   public float getSal()

  {
    return this.salary;

   }

}

多态

public class Demo3 {

       /**

       * @param args

       */

       public static void main(String[] args) {

             // TODO Auto-generated method stub

        //创建一只猫

       /*    Cat cat1=new Cat();

            cat1.cry();

            Dog dog1=new Dog();

            dog1.cry();*/

    Master mast= new Master();

      mast.feed( new Dog(), new Bone() );

    mast.feed( new Cat(), new Fish());            

      }

}

//

class Master

{

       //给动物喂食物，使用多态

       public void feed(Animal an,Food f)

      {

            an.eat();

            f.showName();

      }

}

class Food

{

      String name ;

       public void showName()

      {

            

      }

      

}

class Fish extends Food

{

       public void showName()

      {

            System. out .println( "鱼" );

      }

}

class Bone extends Food

{

       public void showName()

      {

            System. out .println( "骨头" );

      }

}

class Animal

{ //创建父类

       private int age ;

       public int getAge() {

             return age ;

      }

       public void setAge( int age) {

             this . age = age;

      }

       public String getName() {

             return name ;

      }

       public void setName(String name) {

             this . name = name;

      }

       private String name ;

    public void cry()

    {

      System. out .println( "我是动物，不知道怎么叫唤！" );

    }

    public void eat()

    {

      System. out .println( "不知道吃什么" );

    }

}

class Cat extends Animal

{

       //覆盖父类

       public void cry()

      {

            System. out .println( "猫猫叫!" );

      }

       public void eat()

      {

            System. out .println( "猫爱吃鱼！" );

      }

}

class Dog extends Animal

{

       public void cry()

      {

            System. out .println( "汪汪叫！" );

      }

       public void eat()

      {

            System. out .println( "狗爱吃骨头@" );

      }

}

——————————————————————————

方法的重载：

在类的同一种功能的多种实现方式，方法取决于参数

方法名相同

参数的顺序，类型（仅仅是类型或控制访问符号不一样不能构成重载），个数不同

方法的覆盖：（1子类的某个方法和父类的某个方法的名称、返回类型、参数一样；2子类的方法不能缩小父类的方法的访问权限）

根据类的抽象的特征，提取出相同点构成一个父类

就是把父类的方法重写一遍

________________________________________________________________

抽象类的必要性:

当父类的一些方法不能确定时，可以用abstract来修饰这个方法(抽象方法），修饰类时（叫抽象类）

1、抽象方法(含abstract的方法)是绝对不能再父类中实现，只能在子类中实现

2、抽象类不能被实例话(方法都不确定）

3、抽象类可以没有abstract方法

4、抽象方法不能有主体

————————————————————————

接口：是更加抽象的类(体现了多态和高内聚的思想）

接口就是给出一些没有类的方法，封装到一起，到某个类使用的时候，再根据具体情况把这些方法写出来

接口中所有类的方法都不能有主体

接口中可以有变量(本质上是static型的，需初始化或final型，不能是private）

在Java中经常把经常用的变量定义在接口中当全局变量使用（访问形式：接口名.变量名）

一个接口不能继承其他的类，但是可以继承其他的接口

一个类可以实现多个接口

接口和继承可同时发生

 class 类名 implements 接口{

          方法；

          变量；

}

eg

--------------

package zixin;

public class JieKou {

       public static void main(String args[]){

            

            Computer computer= new Computer();

            Camera camera= new Camera();

            Phone phone1= new Phone();

            

            computer.useUsb(camera);

            computer.useUsb(phone1);

            System. out .println(Usb. a );

            

      }

}

//最简单的接口

interface kkk extends Aaa

{

      

}

interface Aaa{

      

}

//Usb接口

interface Usb{

 

       int a =2;

  //声明两个方法

       public void start();

       public void stop();

      

}

//编写照相机类

//当一个类实现了一个接口，就要求这个类把这个接口的

//的方法统统实现

class Camera implements Usb,kkk{

       public void start(){

            System. out .println( "我是照相机，开始工作了" );

            

      }

       public void stop(){

          System. out .println( "我是照相机，停止工作了" );

      }

}

//编写手机类

class Phone implements Usb{

       public void start(){

            System. out .println( "我是手机，开始工作了" );

            

      }

       public void stop(){

          System. out .println( "我是手机，停止工作了" );

      }

}

//计算机

//接口也可以实现多态（只要这个类实现了这个接口

//这个类的一个实例也可直接交给这个接口使用）

class Computer {

       //开始使用usb接口

       public void useUsb(Usb usb){

            usb.start();

            usb.stop();

      }

      

}

______________________________________

final修饰表示成员变量（定义就付初值）或方法不能修改：

一般用于安全的考虑

final修饰类时表不能被覆盖

final class Aaaa{

final folat rate_T=3.14F;

final public void sendMes()

{

System.out.println("发送消息"）；

}

——————————————————————————————————————————————————————————

数组

eg:

 1、int  数组名[]=new int[大小];

 2、int arr[];

     arr=new int[大小];

3、int a[]={2,5,7,8,9}

数组注意事项：

数组可存放同一类型数据

简单的数据类型（int,float)数组，可以直接

对数组在定义后，赋值时需要再次给每个对象分配空间（即：new对象）

数组大小必须事先指定

数组名可以理解为指向数组首地址的引用

数组下标是从0开始的

——————————————

排序：

将一群数据，以一定的顺序排列

1、内部排序

     指需要将处理的所有数据加载到内部存储器中进行排序

     （交换式，选择式，插入式）

2、外部排序

      指数据量过大，无法加载到内存中，需借助外部存储进行排       序（合并，直接合并）

一般数据处理工作的25%的时间是在进行排序

交换式排序:数据经比较后，依判断规则对数据交换的方式进行置换。分冒泡排序，和快速排序。

/*

 * 作者：zhixin

 * 功能：冒泡排序

 */

package com.test1;

public class PaiXu {

       public static void main(String[] args)

     {

       int arr[]={1,6,0,-1,9};

        int temp=0;

         //排序

         //外层循环，决定一共走几趟

         for ( int i=0;i<arr. length ;i++)

         {

            //内存循环，开始逐个比较，交换

            for ( int j=0; j<arr. length -1-i;j ++)

               {

                  if (arr[j]>arr[ j+1])

                   {

                       //换为

                      temp=arr[ j];

                      arr[ j]=arr[j +1];

                      arr[ j+1]=temp;

                              

                    }

                  }

            }

             for ( int i=0;i<arr. length ;i++)

            {

               System. out .print(arr[i]+ " " );

            }

      }