目录
-
主函数与输入输出
主函数
public class Main{
public static void main(String[] args){
}
}常用输入输出
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
System.out.println(n);
}
}-
` 数组
数组的运用与c++类似只是定义的方法不同
在定义数组的时候可以通过参数进行定义。
int[] a=new int[10];
int n=10;
int[] b=new int[n];Math.ceil(3.4)=4//向上取整
Math.floor(2.3)=2//向下取整-
数组常用API
字符串
常用ASICII值：：'A' ~ 'Z' 是 65 - 90 ，'a' ~ 'z' 是97 - 122.。
字符可以参与运算，运算时会将其当成整数。
String类
只能读取不能修改，当有修改操作时不会修改原字符串，会创建一个新字符串。
访问String中的字符时：
String str="Hello World";
for(int i=0;i<str.length();i++)
System.out.print(str.charAt(i));字符串常用API：
StringBuilder、StringBuffer
String 不能被修改，如果打算修改字符串，可以使用 StringBuilder、StringBuffer。
StringBuffer线程安全，速度较慢；StringBuilder线程不安全，速度较快。
StringBuilder sb=new StringBuilder("Hello "); //初始化
sb.append("World"); //使用API拼接字符串
System.out.println(sb);-
类与对象
类与对象
可以把类想成c++中的结构体，在主函数需要用到的时候new一下。
与结构体不同的是类中可以写函数。
public class Main{
public static void main(String[] args){
student stu=new student();
stu.name="小明";
stu.age=21;
stu.print();
System.out.println(stu.age);
}
}
class student{
String name ;
int age=20;
public void print(){
System.out.println(name+"求求你去学会吧");
}
}当创建第二个对象 ，并让第二个对象=第一个是 此时是将第二个对象的地址指向第一个，
所以当第二个对象改变类中某个值时所以对象的值都会改变。
-
方法的重载
方法的重载是在一个类中能够有多个不同的方法（函数），每个方法有不同的参数类型或参数个数。
（可以将多个方法（函数）写在同一个类里且用同一个方法名）
public class Main{
public static void main(String[] args)
{
math math=new math();
math.sum(5);
math.sum(5,4);
}
}
class math{
public void sum(int a,int b){
System.out.println(a+b);
}
public void sum(int a){
System.out.println(a);
}
}-
封装操作
封装的概念：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
其实就是将类的某些信息隐藏起来，不允许外部直接访问而是通过该类提供的方法对信息进行访问和操作。
public class Main{
public static void main(String[] args){
pack pack=new pack();
System.out.println(pack.get());
pack.set(50);
System.out.println(pack.get());
}
}
class pack{
private int a=20;
public int get(){
return a;
}
public int set(int a){
return this.a=a;
}
}class 只能用Public和protected 修饰。
-
构造器
在类中建立构造函数即构造器。
构造器的目的：令方法名和类名一致，便于初始化对象。
当不使用构造器时，对类进行初始化的代码
public class Main{
public static void main(String[] args){
student stu=new student();
stu.ans(20,"xiaoming");
System.out.println(stu.age+" "+stu.name);
}
}
class student{
String name;
int age=30;
public void ans(int n,String str){
this.age=n;
this.name=str;
}
}当使用构造器时，对类进行初始化的代码
public class Main{
public static void main(String[] args){
student stu=new student(20,"xiaoming");
System.out.println(stu.age+" "+stu.name);
}
}
class student{
String name;
int age=30;
public student(int n, String str){
this.age=n;
this.name=str;
}
}构造器简单的说就是在类中定义一个与类名字一样的函数，使在主函数new一个对象的时候直接对 对象进行初始化。
此外，在类中也可以多写几个构造器，让多个构造器之间彼此成为重载。
public class Main{
public static void main(String[] args){
student stu=new student();
stu.print();
student stu1=new student(21,"xiaoming");
stu1.print();
}
}
class student{
String name;
int age;
public student(){
System.out.println("haha haha");
}
public student(int n,String str){
this.age=n;
this.name=str;
}
public void print(){
System.out.println(age+" "+ name );
}
}类的继承与多态
继承允许一个类成为另一个类的子类，子类继承了父类的所有特性，并且可以扩展出自己的特征 。
简单的说就是子类可以使用父类的所有变量和方法之外还能有自己的变量和方法。
public class Main {
public static void main(String[] args) {
son s = new son();
s.name="xiao li ";
s.print();
s.text();
System.out.println(s.age+" "+s.name);
}
}
class father{
int age=55;
String name;
public void print(){
System.out.println("这是父类");
}
}
class son extends father{
public void text(){
System.out.println("这是子类");
}
}
当父类使用构造函数 初始化的时候，子类中也要有构造函数且super() 调用必须是构造函数主体中的第一条语句。
public class Main{
public static void main(String[] args){
son s=new son(22,"xiaowang");
System.out.println(s.agg);
s.student();
}
}
class father{
int agg=55;
String name1 ="li ming ";
public father(int age, String name) {
this.agg=age;
this.name1=name;
System.out.println("这是父类");
}
}
class son extends father{
int age;
String name ;
public son(int age, String name ) {
super(age,name);
System.out.println(age+" "+name);
System.out.println("这是子类");
}
void student(){
System.out.println("快去学习吧");
}
}输出结果
在JAVA中其实所有的类都继承Object类。
方法的重写
方法的重写是指 可以在子类中写一个与父类中某一方法名字一样，参数数量类型都相同的方法 ，以此来改变此方法的作用。
子类通过方法的重写可以隐藏继承的方法，进而再次使用时 ，调用的就是 重写后的方法。
public class Main{
public static void main(String[] args){
son s=new son();
s.print();
}
}
class father{
int agg=55;
String name1 ="li ming ";
public void print(){
System.out.println("快点去学习！！！");
}
}
class son extends father{
int age;
String name ;
public void print(){
System.out.println("我想去吃饭了");
}
}抽象类
抽象类是指在使父类的方法抽象，然后子类中必须重写父类中抽象的方法。
一些理解：实现一些方法时，先在父类中实现大概轮廓（定义方法名）
子类中给出具体的实现方法。
例如 : 在设计地图时，首先考虑地图最重要的轮廓，不必去考虑诸如城市中的街道牌子等细节。细节应当由抽象类的非抽象子类去实现，这些子类可以给出具体的实例，来完成程序功能的具体实现。
public class Main{
public static void main(String[] args){
son s=new son();
s.print();
}
}
abstract class father{
int agg=55;
String name1 ="li ming ";
public abstract void print();
}
class son extends father{
int age;
String name ;
@Override
public void print() {///子类必须重写父类中的抽象方法
System.out.println("我想去吃饭了");}
}接口
接口只代表某个确切的功能，也就是只包含方法的定义，接口甚至不是一个类。
使用implements关键字来实现接口。
在实现接口是需要将接口内的所有方法都实现。
多态
new一个子类 定义为父类。
编译看左运行看右。
编译时只能引用父类中存在的方法，
但在运行时 运行子类中的方法。
public class Main{
public static void main(String[] args){
father son1=new son();
son1.bb();
son1.aa();
}
}
class father{
public void aa(){
System.out.println("该吃饭了");
}
public void bb(){
System.out.println("liming");
}
}
class son extends father {
public void aa(){
System.out.println("还没到吃饭时间");
}
}简单点说:多态就是 “一个接口，多种实现”，就是同一种事物表现出的多种形态。
1、提高了代码的维护性(继承保证)
2、提高了代码的扩展性(由多态保证)
3、把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
扫一扫
185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
